@ozanarslan/corpus 0.1.4 → 0.1.6

package/dist/index.js

@@ -14,23 +14,51 @@ var __export = (target, all) => {
     });
 };
 
-// src/exports.ts
-var exports_exports = {};
-__export(exports_exports, {
+// src/Store/StoreAbstract.ts
+class StoreAbstract {
+  set(value) {
+    this.value = value;
+  }
+  get() {
+    return this.value;
+  }
+}
+
+// src/Store/globals/GlobalPrefixStore.ts
+class GlobalPrefixStore extends StoreAbstract {
+  value = "";
+}
+
+// src/Store/globals/GlobalRouterStore.ts
+class GlobalRouterStore extends StoreAbstract {
+  value = null;
+  get() {
+    if (!this.value) {
+      console.error("Router instance is not set. Please instantiate your Server before your routes.");
+      process.exit(1);
+    }
+    return this.value;
+  }
+}
+
+// src/Store/globals/GlobalCorsStore.ts
+class GlobalCorsStore extends StoreAbstract {
+  value = null;
+}
+
+// src/C.ts
+var exports_C = {};
+__export(exports_C, {
   Status: () => Status,
   StaticRoute: () => StaticRoute,
   Server: () => Server,
   Route: () => Route,
-  Response: () => HttpResponse,
-  Request: () => HttpRequest,
-  Repository: () => RepositoryAbstract,
-  Parser: () => Parser,
+  Response: () => CResponse,
+  Request: () => CRequest,
   Middleware: () => Middleware,
   Method: () => Method,
-  Headers: () => HttpHeaders,
-  FileWalker: () => FileWalker,
-  Error: () => HttpError,
-  DefaultStatusTexts: () => DefaultStatusTexts,
+  Headers: () => CHeaders,
+  Error: () => CError,
   Cookies: () => Cookies,
   Controller: () => ControllerAbstract,
   Context: () => Context,
@@ -106,7 +134,7 @@ class Config {
     this.env[key] = value;
   }
 }
-// src/Response/enums/Status.ts
+// src/CResponse/enums/Status.ts
 var Status = {
   CONTINUE: 100,
   SWITCHING_PROTOCOLS: 101,
@@ -172,7 +200,7 @@ var Status = {
   NETWORK_AUTHENTICATION_REQUIRED: 511
 };
 
-// src/Response/enums/DefaultStatusTexts.ts
+// src/CResponse/enums/DefaultStatusTexts.ts
 var DefaultStatusTexts = {
   [Status.OK]: "OK",
   [Status.CREATED]: "Created",
@@ -189,11 +217,12 @@ var DefaultStatusTexts = {
   [Status.INTERNAL_SERVER_ERROR]: "Internal Server Error"
 };
 
-// src/Headers/enums/CommonHeaders.ts
+// src/CHeaders/enums/CommonHeaders.ts
 var CommonHeaders = {
   CacheControl: "Cache-Control",
   ContentType: "Content-Type",
   ContentLength: "Content-Length",
+  ContentDisposition: "Content-Disposition",
   AcceptEncoding: "Accept-Encoding",
   Accept: "Accept",
   Authorization: "Authorization",
@@ -283,8 +312,8 @@ class CookiesUsingBun extends CookiesAbstract {
 class Cookies extends CookiesUsingBun {
 }
 
-// src/Headers/HttpHeaders.ts
-class HttpHeaders extends Headers {
+// src/CHeaders/CHeaders.ts
+class CHeaders extends Headers {
   constructor(init) {
     super(init);
   }
@@ -314,7 +343,7 @@ class HttpHeaders extends Headers {
     return target;
   }
   innerCombine(source) {
-    HttpHeaders.combine(source, this);
+    CHeaders.combine(source, this);
   }
   setMany(init) {
     const entries = Array.isArray(init) ? init : Object.entries(init);
@@ -325,7 +354,7 @@ class HttpHeaders extends Headers {
     }
   }
   static findHeaderInInit(init, name) {
-    if (init instanceof HttpHeaders || init instanceof Headers) {
+    if (init instanceof CHeaders || init instanceof Headers) {
       return init.get(name);
     } else if (Array.isArray(init)) {
       return init.find((entry) => entry[0] === name)?.[1] ?? null;
@@ -335,19 +364,139 @@ class HttpHeaders extends Headers {
   }
 }
 
-// src/Response/HttpResponse.ts
-class HttpResponse {
-  body;
+// src/utils/isNil.ts
+function isNil(input) {
+  return input === null || input === undefined;
+}
+
+// src/utils/isPrimitive.ts
+function isPrimitive(input) {
+  return typeof input === "string" || typeof input === "number" || typeof input === "boolean" || typeof input === "bigint";
+}
+
+// src/utils/isPlainObject.ts
+function isPlainObject(input) {
+  return typeof input === "object" && input !== null && input.constructor === Object;
+}
+
+// src/CError/CError.ts
+class CError extends Error {
+  message;
+  status;
+  data;
+  constructor(message, status, data) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.data = data;
+  }
+  toResponse() {
+    return new CResponse(this.data ? { error: this.data, message: this.message } : { error: true, message: this.message }, { status: this.status });
+  }
+  isStatusOf(status) {
+    return this.status === status;
+  }
+  static internalServerError(msg) {
+    const status = Status.INTERNAL_SERVER_ERROR;
+    return new this(msg ?? status.toString(), status);
+  }
+  static badRequest(msg) {
+    const status = Status.BAD_REQUEST;
+    return new this(msg ?? status.toString(), status);
+  }
+  static notFound(msg) {
+    const status = Status.NOT_FOUND;
+    return new this(msg ?? status.toString(), status);
+  }
+  static methodNotAllowed(msg) {
+    const status = Status.METHOD_NOT_ALLOWED;
+    return new this(msg ?? status.toString(), status);
+  }
+  static unprocessableEntity(msg) {
+    const status = Status.UNPROCESSABLE_ENTITY;
+    return new this(msg ?? status.toString(), status);
+  }
+}
+
+// src/XFile/XFileAbstract.ts
+class XFileAbstract {
+  path;
+  fallbackExtension;
+  constructor(path2, fallbackExtension) {
+    this.path = path2;
+    this.fallbackExtension = fallbackExtension;
+  }
+  get name() {
+    return this.path.split("/").pop() ?? this.path;
+  }
+  get extension() {
+    return this.path.split(".").pop() ?? this.fallbackExtension ?? "txt";
+  }
+  get mimeType() {
+    const mimeTypes = {
+      html: "text/html",
+      htm: "text/html",
+      css: "text/css",
+      js: "application/javascript",
+      ts: "application/javascript",
+      mjs: "application/javascript",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      ico: "image/x-icon",
+      txt: "text/plain",
+      xml: "application/xml",
+      pdf: "application/pdf",
+      zip: "application/zip",
+      mp3: "audio/mpeg",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      woff: "font/woff",
+      woff2: "font/woff2",
+      ttf: "font/ttf"
+    };
+    return mimeTypes[this.extension] ?? "application/octet-stream";
+  }
+}
+
+// src/XFile/XFileUsingBun.ts
+class XFileUsingBun extends XFileAbstract {
+  constructor(...args) {
+    super(...args);
+    this.file = Bun.file(args[0]);
+  }
+  file;
+  async exists() {
+    return await this.file.exists();
+  }
+  async text() {
+    return await this.file.text();
+  }
+  stream() {
+    return this.file.stream();
+  }
+}
+
+// src/XFile/XFile.ts
+class XFile extends XFileUsingBun {
+}
+// src/CResponse/CResponse.ts
+class CResponse {
+  data;
   init;
-  constructor(body, init) {
-    this.body = body;
+  constructor(data, init) {
+    this.data = data;
     this.init = init;
-    this.cookies = this.getCookies();
-    this.headers = this.getHeaders();
-    this.body = this.getBody();
-    this.status = this.getStatus();
+    this.cookies = this.resolveCookies();
+    this.headers = this.resolveHeaders();
+    this.body = this.resolveBody();
+    this.status = this.resolveStatus();
     this.statusText = this.getDefaultStatusText();
   }
+  body;
   headers;
   status;
   statusText;
@@ -359,11 +508,126 @@ class HttpResponse {
       headers: this.headers
     });
   }
-  getCookies() {
+  static redirect(url, init) {
+    const res = new CResponse(undefined, {
+      ...init,
+      status: init?.status ?? Status.FOUND,
+      statusText: init?.statusText ?? DefaultStatusTexts[Status.FOUND]
+    });
+    const urlString = url instanceof URL ? url.toString() : url;
+    res.headers.set(CommonHeaders.Location, urlString);
+    return res;
+  }
+  static permanentRedirect(url, init) {
+    return this.redirect(url, {
+      ...init,
+      status: Status.MOVED_PERMANENTLY
+    });
+  }
+  static temporaryRedirect(url, init) {
+    return this.redirect(url, { ...init, status: Status.TEMPORARY_REDIRECT });
+  }
+  static seeOther(url, init) {
+    return this.redirect(url, { ...init, status: Status.SEE_OTHER });
+  }
+  static createStream(execute) {
+    let cancelled = false;
+    let cleanup;
+    return new ReadableStream({
+      start(controller) {
+        try {
+          cleanup = execute(controller, () => cancelled);
+          if (typeof cleanup !== "function") {
+            controller.close();
+          }
+        } catch (err) {
+          controller.error(err);
+        }
+      },
+      cancel() {
+        cancelled = true;
+        cleanup?.();
+      }
+    });
+  }
+  static sse(source, init, retry) {
+    const encoder = new TextEncoder;
+    const stream = CResponse.createStream((controller, isCancelled) => {
+      return source((event) => {
+        if (isCancelled())
+          return;
+        let chunk = "";
+        if (retry !== undefined)
+          chunk += `retry: ${retry}
+`;
+        if (event.id)
+          chunk += `id: ${event.id}
+`;
+        if (event.event)
+          chunk += `event: ${event.event}
+`;
+        chunk += `data: ${JSON.stringify(event.data)}
+
+`;
+        controller.enqueue(encoder.encode(chunk));
+      });
+    });
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: "text/event-stream",
+      [CommonHeaders.CacheControl]: "no-cache",
+      [CommonHeaders.Connection]: "keep-alive"
+    });
+    return res;
+  }
+  static ndjson(source, init) {
+    const encoder = new TextEncoder;
+    const stream = CResponse.createStream((controller, isCancelled) => {
+      return source((item) => {
+        if (isCancelled())
+          return;
+        controller.enqueue(encoder.encode(`${JSON.stringify(item)}
+`));
+      });
+    });
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: "application/x-ndjson",
+      [CommonHeaders.CacheControl]: "no-cache"
+    });
+    return res;
+  }
+  static async streamFile(filePath, disposition = "attachment", init) {
+    const file = new XFile(filePath);
+    if (!file) {
+      throw CError.notFound();
+    }
+    const stream = file.stream();
+    const res = new CResponse(stream, { ...init, status: Status.OK });
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: file.mimeType,
+      [CommonHeaders.ContentDisposition]: `${disposition}; filename="${file.name}"`
+    });
+    return res;
+  }
+  static async file(filePath, init) {
+    const file = new XFile(filePath);
+    if (!file) {
+      throw CError.notFound();
+    }
+    const content = await file.text();
+    const res = new CResponse(content, init);
+    res.headers.setMany({
+      [CommonHeaders.ContentType]: file.mimeType,
+      [CommonHeaders.ContentLength]: content.length.toString()
+    });
+    return res;
+  }
+  resolveCookies() {
     return new Cookies(this.init?.cookies);
   }
-  getHeaders() {
-    const headers = new HttpHeaders(this.init?.headers);
+  resolveHeaders() {
+    const headers = new CHeaders(this.init?.headers);
     const setCookieHeaders = this.cookies.toSetCookieHeaders();
     if (setCookieHeaders.length > 0) {
       for (const header of setCookieHeaders) {
@@ -372,7 +636,7 @@ class HttpResponse {
     }
     return headers;
   }
-  getStatus() {
+  resolveStatus() {
     if (this.init?.status)
       return this.init.status;
     if (this.headers.has(CommonHeaders.Location)) {
@@ -385,58 +649,53 @@ class HttpResponse {
       this.headers.set(CommonHeaders.ContentType, value);
     }
   }
-  getBody() {
-    if (this.body === null || this.body === undefined) {
+  resolveBody() {
+    if (isNil(this.data)) {
       this.setContentType("text/plain");
       return "";
     }
-    if (typeof this.body !== "object") {
+    if (isPrimitive(this.data)) {
       this.setContentType("text/plain");
-      return String(this.body);
+      return String(this.data);
+    }
+    if (this.data instanceof ArrayBuffer) {
+      this.setContentType("application/octet-stream");
+      return this.data;
+    }
+    if (this.data instanceof Blob) {
+      if (this.data.type)
+        this.setContentType(this.data.type);
+      return this.data;
+    }
+    if (this.data instanceof FormData) {
+      this.setContentType("multipart/form-data");
+      return this.data;
+    }
+    if (this.data instanceof URLSearchParams) {
+      this.setContentType("application/x-www-form-urlencoded");
+      return this.data;
     }
-    if (this.body instanceof ArrayBuffer || this.body instanceof Blob || this.body instanceof FormData || this.body instanceof URLSearchParams || this.body instanceof ReadableStream) {
-      throw new Error("Unsupported response body: ArrayBuffer | Blob | FormData | URLSearchParams | ReadableStream");
+    if (this.data instanceof ReadableStream) {
+      return this.data;
     }
-    if (this.body instanceof Date) {
+    if (this.data instanceof Date) {
       this.setContentType("text/plain");
-      return this.body.toISOString();
+      return this.data.toISOString();
     }
-    if (Array.isArray(this.body) || this.body.constructor === Object) {
+    if (Array.isArray(this.data) || isPlainObject(this.data)) {
       this.setContentType("application/json");
-      return JSON.stringify(this.body);
+      return JSON.stringify(this.data);
     }
     this.setContentType("text/plain");
-    return String(this.body);
+    return String(this.data);
   }
   getDefaultStatusText() {
     const key = this.status;
     return DefaultStatusTexts[key] ?? "Unknown";
   }
-  static redirect(url, init) {
-    const res = new HttpResponse(undefined, {
-      ...init,
-      status: init?.status ?? Status.FOUND,
-      statusText: init?.statusText ?? DefaultStatusTexts[Status.FOUND]
-    });
-    const urlString = url instanceof URL ? url.toString() : url;
-    res.headers.set(CommonHeaders.Location, urlString);
-    return res;
-  }
-  static permanentRedirect(url, init) {
-    return this.redirect(url, {
-      ...init,
-      status: Status.MOVED_PERMANENTLY
-    });
-  }
-  static temporaryRedirect(url, init) {
-    return this.redirect(url, { ...init, status: Status.TEMPORARY_REDIRECT });
-  }
-  static seeOther(url, init) {
-    return this.redirect(url, { ...init, status: Status.SEE_OTHER });
-  }
 }
 
-// src/Request/enums/Method.ts
+// src/CRequest/enums/Method.ts
 var Method = {
   GET: "GET",
   POST: "POST",
@@ -449,45 +708,6 @@ var Method = {
   TRACE: "TRACE"
 };
 
-// src/Error/HttpError.ts
-class HttpError extends Error {
-  message;
-  status;
-  data;
-  constructor(message, status, data) {
-    super(message);
-    this.message = message;
-    this.status = status;
-    this.data = data;
-  }
-  toResponse() {
-    return new HttpResponse(this.data ? { error: this.data, message: this.message } : { error: true, message: this.message }, { status: this.status });
-  }
-  isStatusOf(status) {
-    return this.status === status;
-  }
-  static internalServerError(msg) {
-    const status = Status.INTERNAL_SERVER_ERROR;
-    return new this(msg ?? status.toString(), status);
-  }
-  static badRequest(msg) {
-    const status = Status.BAD_REQUEST;
-    return new this(msg ?? status.toString(), status);
-  }
-  static notFound(msg) {
-    const status = Status.NOT_FOUND;
-    return new this(msg ?? status.toString(), status);
-  }
-  static methodNotAllowed(msg) {
-    const status = Status.METHOD_NOT_ALLOWED;
-    return new this(msg ?? status.toString(), status);
-  }
-  static unprocessableEntity(msg) {
-    const status = Status.UNPROCESSABLE_ENTITY;
-    return new this(msg ?? status.toString(), status);
-  }
-}
-
 // src/utils/arrIncludes.ts
 function arrIncludes(input, array) {
   return array.includes(input);
@@ -516,7 +736,7 @@ class Parser {
     const result = await validate(data);
     if (result.issues !== undefined) {
       const msg = this.issuesToErrorMessage(result.issues);
-      throw HttpError.unprocessableEntity(msg);
+      throw CError.unprocessableEntity(msg);
     }
     return result.value;
   }
@@ -532,14 +752,14 @@ class Parser {
     }).join(`
 `);
   }
-  static async getSearch(url, validate) {
+  static async parseUrlData(params, validate) {
     const data = {};
-    for (const [key, value] of url.searchParams ?? {}) {
-      data[key] = this.processString(value);
+    for (const [key, value] of Object.entries(params)) {
+      data[key] = decodeURIComponent(value);
     }
     return await this.parse(data, validate);
   }
-  static async getBody(r, validate) {
+  static async parseBody(r, validate) {
     let data;
     const empty = {};
     const input = r instanceof Request ? r : r instanceof Response ? r : r.response;
@@ -566,7 +786,7 @@ class Parser {
         case "image":
         case "audio":
         case "video":
-          throw new HttpError("unprocessable.contentType", Status.UNPROCESSABLE_ENTITY);
+          throw new CError("unprocessable.contentType", Status.UNPROCESSABLE_ENTITY);
         case "no-body-allowed":
         default:
           return empty;
@@ -578,23 +798,6 @@ class Parser {
       throw err;
     }
   }
-  static async getParams(endpoint, url, validate) {
-    const data = {};
-    if (!endpoint.includes(":")) {
-      return data;
-    }
-    const defParts = endpoint.split("/");
-    const reqParts = url.pathname.split("/");
-    for (const [i, defPart] of defParts.entries()) {
-      const reqPart = reqParts[i];
-      if (defPart.startsWith(":") && reqPart !== undefined) {
-        const key = defPart.slice(1);
-        const value = this.processString(decodeURIComponent(reqPart));
-        data[key] = value;
-      }
-    }
-    return await this.parse(data, validate);
-  }
   static async getUnknownBody(input, validate) {
     if (!validate) {
       return await this.getTextBody(input);
@@ -616,7 +819,7 @@ class Parser {
     const params = new URLSearchParams(text);
     const body = {};
     for (const [key, value] of params.entries()) {
-      objAppendEntry(body, key, this.processString(value));
+      objAppendEntry(body, key, value);
     }
     return body;
   }
@@ -628,7 +831,7 @@ class Parser {
       if (value instanceof File) {
         body[key] = value;
       } else {
-        objAppendEntry(body, key, this.processString(value));
+        objAppendEntry(body, key, value);
       }
     }
     return body;
@@ -637,16 +840,14 @@ class Parser {
     const contentLength = input.headers.get(CommonHeaders.ContentLength);
     const length = contentLength ? parseInt(contentLength) : 0;
     if (length > 0 && length < 1024 * 1024) {
-      const text2 = await input.text();
-      return this.processString(text2);
+      return await input.text();
     }
     const buffer = await input.arrayBuffer();
     const contentType = input.headers.get(CommonHeaders.ContentType) || "";
     const match = contentType.match(/charset=([^;]+)/i);
     const charset = match?.[1] ? match[1].trim() : null;
     const decoder = new TextDecoder(charset || "utf-8");
-    const text = decoder.decode(buffer);
-    return this.processString(text);
+    return decoder.decode(buffer);
   }
   static getNormalizedContentType(input) {
     const contentTypeHeader = input.headers.get(CommonHeaders.ContentType) || "";
@@ -683,17 +884,6 @@ class Parser {
     }
     return "unknown";
   }
-  static processString(value) {
-    let processedValue = value;
-    if (!strIsDefined(value))
-      return "";
-    if (/^-?\d+(\.\d+)?$/.test(value)) {
-      processedValue = Number(value);
-    } else if (value.toLowerCase() === "true" || value.toLowerCase() === "false") {
-      processedValue = value.toLowerCase() === "true";
-    }
-    return processedValue;
-  }
 }
 
 // src/Context/Context.ts
@@ -706,7 +896,7 @@ class Context {
     this.body = body;
     this.search = search;
     this.params = params;
-    this.res = res ?? new HttpResponse;
+    this.res = res ?? new CResponse;
   }
   req;
   url;
@@ -720,10 +910,10 @@ class Context {
   static makeFromRequest(req) {
     return new Context(req, {}, {}, {});
   }
-  static async appendParsedData(ctx, req, endpoint, model) {
-    ctx.body = await Parser.getBody(req, model?.body);
-    ctx.search = await Parser.getSearch(ctx.url, model?.search);
-    ctx.params = await Parser.getParams(endpoint, ctx.url, model?.params);
+  static async appendParsedData(ctx, req, params, search, model) {
+    ctx.body = await Parser.parseBody(req, model?.body);
+    ctx.params = await Parser.parseUrlData(params, model?.params);
+    ctx.search = await Parser.parseUrlData(search, model?.search);
   }
 }
 // src/Route/enums/RouteVariant.ts
@@ -738,15 +928,12 @@ function joinPathSegments(...segments) {
   return `/${joined}`;
 }
 
-// src/Config/constants/_globalPrefixEnvKey.ts
-var _globalPrefixEnvKey = "CORPUS_GLOBAL_PREFIX";
-
 // src/Route/RouteAbstract.ts
 class RouteAbstract {
   resolveEndpoint(definition, variant) {
     const endpoint = typeof definition === "string" ? definition : definition.path;
     if (variant === RouteVariant.dynamic) {
-      return joinPathSegments(Config.get(_globalPrefixEnvKey, { fallback: "" }), endpoint);
+      return joinPathSegments(_prefixStore.get(), endpoint);
     }
     return endpoint;
   }
@@ -754,8 +941,7 @@ class RouteAbstract {
     return typeof definition === "string" ? Method.GET : definition.method;
   }
   resolvePattern(endpoint) {
-    const regex = endpoint.split("/").map((part) => part.startsWith(":") ? "([^\\/]+)" : part).join("/");
-    return new RegExp(`^${regex}$`);
+    return Route.makeRoutePattern(endpoint);
   }
   resolveId(method, endpoint) {
     return Route.makeRouteId(method, endpoint);
@@ -773,9 +959,9 @@ class Route extends RouteAbstract {
     this.id = this.resolveId(this.method, this.endpoint);
     this.model = model;
     this.handler = handler;
-    getRouterInstance().addRoute(this);
+    _routerStore.get().addRoute(this);
     if (model) {
-      getRouterInstance().addModel(this.id, model);
+      _routerStore.get().addModel(this, model);
     }
   }
   variant;
@@ -788,61 +974,25 @@ class Route extends RouteAbstract {
   static makeRouteId(method, endpoint) {
     return `${method.toUpperCase()} ${endpoint}`;
   }
-}
-
-// src/FileWalker/FileWalkerUsingBun.ts
-class FileWalkerUsingBun {
-  static async read(address) {
-    try {
-      const file = await this.find(address);
-      if (!file)
-        return null;
-      return await file.text();
-    } catch {
-      return null;
-    }
-  }
-  static async exists(address) {
-    return await this.find(address) !== null;
-  }
-  static getExtension(address) {
-    return address.split(".").pop() ?? "txt";
-  }
-  static async find(address) {
-    const file = Bun.file(address);
-    const exists = await file.exists();
-    if (exists) {
-      return { text: () => file.text() };
-    }
-    return null;
+  static makeRoutePattern(endpoint) {
+    const regex = endpoint.split("/").map((part) => part.startsWith(":") ? "([^\\/]+)" : part).join("/");
+    return new RegExp(`^${regex}$`);
   }
 }
 
-// src/FileWalker/FileWalker.ts
-class FileWalker extends FileWalkerUsingBun {
-}
-
 // src/Route/StaticRoute.ts
 class StaticRoute extends RouteAbstract {
-  filePath;
-  constructor(path2, filePath, handler, model) {
+  constructor(path2, definition, handler, model) {
     super();
-    this.filePath = filePath;
     this.variant = RouteVariant.static;
     this.endpoint = this.resolveEndpoint(path2, this.variant);
     this.method = Method.GET;
     this.pattern = this.resolvePattern(this.endpoint);
     this.id = this.resolveId(this.method, this.endpoint);
     this.model = model;
-    if (handler) {
-      this.handler = async (c) => {
-        const content = await this.defaultHandler(c);
-        return handler(c, content);
-      };
-    } else {
-      this.handler = this.defaultHandler;
-    }
-    getRouterInstance().addRoute(this);
+    this.filePath = this.resolveFilePath(definition);
+    this.handler = this.resolveHandler(definition, handler);
+    _routerStore.get().addRoute(this);
   }
   id;
   variant;
@@ -851,73 +1001,30 @@ class StaticRoute extends RouteAbstract {
   pattern;
   model;
   handler;
-  defaultHandler = async (c) => {
-    let content = "";
-    switch (this.extension) {
-      case "html":
-        content = await this.handleHtml();
-        break;
-      case "css":
-        content = await this.handleCss();
-        break;
-      case "js":
-        content = await this.handleJs();
-        break;
-      default:
-        content = await this.handleFile();
-        break;
+  filePath;
+  resolveFilePath(definition) {
+    return typeof definition === "string" ? definition : definition.filePath;
+  }
+  resolveHandler(definition, customHandler) {
+    if (customHandler !== undefined) {
+      return async (c) => {
+        const file = new XFile(this.filePath);
+        if (!file) {
+          console.error("File not found at:", this.filePath);
+          throw CError.notFound();
+        }
+        const content = await file.text();
+        c.res.headers.setMany({
+          [CommonHeaders.ContentType]: file.mimeType,
+          [CommonHeaders.ContentLength]: content.length.toString()
+        });
+        return customHandler(c, content);
+      };
+    } else if (typeof definition === "string") {
+      return async () => await CResponse.file(this.filePath);
+    } else {
+      return async () => await CResponse.streamFile(this.filePath);
     }
-    c.res.headers.set(CommonHeaders.ContentType, this.mimeTypes[this.extension] || "application/octet-stream");
-    c.res.headers.set(CommonHeaders.ContentLength, content.length.toString());
-    return content;
-  };
-  get extension() {
-    return this.filePath.split(".").pop() || "txt";
-  }
-  async getContent() {
-    const content = await FileWalker.read(this.filePath);
-    if (!content) {
-      console.error("File not found at:", this.filePath);
-      throw HttpError.notFound();
-    }
-    return content;
-  }
-  mimeTypes = {
-    html: "text/html",
-    htm: "text/html",
-    css: "text/css",
-    js: "application/javascript",
-    ts: "application/javascript",
-    mjs: "application/javascript",
-    json: "application/json",
-    png: "image/png",
-    jpg: "image/jpeg",
-    jpeg: "image/jpeg",
-    gif: "image/gif",
-    svg: "image/svg+xml",
-    ico: "image/x-icon",
-    txt: "text/plain",
-    xml: "application/xml",
-    pdf: "application/pdf",
-    zip: "application/zip",
-    mp3: "audio/mpeg",
-    mp4: "video/mp4",
-    webm: "video/webm",
-    woff: "font/woff",
-    woff2: "font/woff2",
-    ttf: "font/ttf"
-  };
-  async handleHtml() {
-    return await this.getContent();
-  }
-  async handleCss() {
-    return await this.getContent();
-  }
-  async handleJs() {
-    return await this.getContent();
-  }
-  async handleFile() {
-    return await this.getContent();
   }
 }
 
@@ -960,18 +1067,11 @@ class Middleware {
   constructor(opts) {
     this.useOn = opts.useOn;
     this.handler = opts.handler;
-    getRouterInstance().addMiddleware(opts);
+    _routerStore.get().addMiddleware(opts);
   }
   useOn;
   handler;
 }
-// src/Repository/RepositoryAbstract.ts
-class RepositoryAbstract {
-  db;
-  constructor(db) {
-    this.db = db;
-  }
-}
 // src/utils/assert.ts
 function assert(condition, message) {
   const conditionName = String(condition);
@@ -995,8 +1095,8 @@ function strSplit(mark, input, minLength) {
   return parts;
 }
 
-// src/Request/HttpRequest.ts
-class HttpRequest extends Request {
+// src/CRequest/CRequest.ts
+class CRequest extends Request {
   info;
   init;
   constructor(info, init) {
@@ -1018,7 +1118,7 @@ class HttpRequest extends Request {
       case this.info instanceof URL:
         urlObject = this.info;
         break;
-      case this.info instanceof HttpRequest:
+      case this.info instanceof CRequest:
         urlObject = this.info.urlObject;
         break;
       case this.info instanceof Request:
@@ -1035,12 +1135,12 @@ class HttpRequest extends Request {
   }
   resolveHeaders() {
     if (this.init?.headers !== undefined) {
-      return new HttpHeaders(this.init.headers);
+      return new CHeaders(this.init.headers);
     }
-    if (this.info instanceof Request || this.info instanceof HttpRequest) {
-      return new HttpHeaders(this.info.headers);
+    if (this.info instanceof Request || this.info instanceof CRequest) {
+      return new CHeaders(this.info.headers);
     }
-    return new HttpHeaders;
+    return new CHeaders;
   }
   resolveCookies() {
     const jar = new Cookies;
@@ -1079,96 +1179,45 @@ function strIsEqual(source, target, modifier) {
   return source === target;
 }
 
+// src/Store/LazyMap.ts
+class LazyMap {
+  constructor() {
+    return new Proxy(this, {
+      get(target, prop) {
+        const val = Reflect.get(target.map, prop);
+        return typeof val === "function" ? val.bind(target.map) : val;
+      }
+    });
+  }
+  _map;
+  get map() {
+    if (!this._map) {
+      this._map = new Map;
+    }
+    return this._map;
+  }
+  get [Symbol.toStringTag]() {
+    return "LazyMap";
+  }
+}
+
 // src/utils/strRemoveWhitespace.ts
 function strRemoveWhitespace(str) {
   return str.trim().replace(/\s+/g, "");
 }
 
-// src/Router/Router.ts
-class Router {
-  _routes;
-  _middlewares;
-  _models;
-  internFuncMap = new Map;
-  cache = new WeakMap;
-  get routes() {
-    if (!this._routes) {
-      this._routes = new Map;
-    }
-    return this._routes;
-  }
-  get models() {
-    if (!this._models) {
-      this._models = new Map;
-    }
-    return this._models;
-  }
-  get middlewares() {
-    if (!this._middlewares) {
-      this._middlewares = new Map;
-    }
-    return this._middlewares;
-  }
-  globalPrefix = "";
-  setGlobalPrefix(value) {
-    this.globalPrefix = value;
-  }
-  getRouteHandler(req) {
-    const cached = this.cache.get(req);
-    if (cached) {
-      return cached;
-    }
-    const route = this.findRoute(req);
-    const ctx = Context.makeFromRequest(req);
-    const middleware = this.findRouterMiddlewareData(route.id);
-    const model = this.findModel(route.id);
-    const handler = async () => {
-      await middleware?.(ctx);
-      await Context.appendParsedData(ctx, req, route.endpoint, model);
-      const result = await route.handler(ctx);
-      return result instanceof HttpResponse ? result : new HttpResponse(result, {
-        cookies: ctx.res.cookies,
-        headers: ctx.res.headers,
-        status: ctx.res.status,
-        statusText: ctx.res.statusText
-      });
-    };
-    this.cache.set(req, handler);
-    return handler;
-  }
-  getRouteList() {
-    return Array.from(this.routes.values()).map((r) => [r.method, r.endpoint]);
-  }
-  addRoute(r) {
-    const handler = this.intern(r.handler, "route", r.id);
-    this.checkPossibleCollision(r);
-    this.routes.set(r.endpoint, {
-      id: r.id,
-      endpoint: r.endpoint,
-      method: r.method,
-      handler,
-      pattern: r.pattern
-    });
-  }
-  addMiddleware(m) {
-    const useOn = m.useOn;
-    const handler = this.intern(m.handler, "middleware", m.handler.toString());
-    if (useOn === "*") {
-      this.middlewares.set("*", this.compile([this.middlewares.get("*"), handler]));
-      return;
-    }
-    for (const target of Array.isArray(useOn) ? useOn : [useOn]) {
-      const routeIds = target instanceof Route ? [target.id] : target instanceof ControllerAbstract ? Array.from(target.routeIds) : [];
-      for (const routeId of routeIds) {
-        this.middlewares.set(routeId, this.compile([
-          this.middlewares.get("*"),
-          this.middlewares.get(routeId),
-          handler
-        ]));
-      }
-    }
-  }
-  addModel(routeId, model) {
+// src/Router/registries/ModelRegistry.ts
+class ModelRegistry {
+  map = new LazyMap;
+  add(method, endpoint, model) {
+    const entry = ModelRegistry.toRouterModelData(model);
+    this.map.set(Route.makeRouteId(method, endpoint), entry);
+  }
+  find(routeId) {
+    return this.map.get(routeId);
+  }
+  static internFuncMap = new LazyMap;
+  static toRouterModelData(model) {
     const entry = {};
     for (const k of Object.keys(model)) {
       const key = k;
@@ -1178,69 +1227,166 @@ class Router {
       const handler = schema["~standard"].validate;
       entry[key] = this.intern(handler, "model", strRemoveWhitespace(JSON.stringify(schema)));
     }
-    this.models.set(routeId, entry);
+    return entry;
   }
-  findRouterMiddlewareData(routeId) {
-    return this.middlewares.get(routeId);
+  static intern(value, ...namespace) {
+    const key = namespace.join("::");
+    const existing = this.internFuncMap.get(key);
+    if (existing)
+      return existing;
+    this.internFuncMap.set(key, value);
+    return value;
   }
-  findModel(routeId) {
-    return this.models.get(routeId);
+}
+
+// src/utils/compile.ts
+function compile(fns) {
+  return async (...args) => {
+    for (const fn of fns) {
+      if (!fn)
+        continue;
+      await fn(...args);
+    }
+  };
+}
+
+// src/Router/registries/MiddlewareRegistry.ts
+class MiddlewareRegistry {
+  middlewares = new LazyMap;
+  add(m) {
+    const resolved = MiddlewareRegistry.resolveRouteIds(m);
+    if (resolved.isGlobal) {
+      const existing = this.middlewares.get("*") ?? [];
+      this.middlewares.set("*", [...existing, m.handler]);
+      return;
+    }
+    for (const routeId of resolved.routeIds) {
+      const existing = this.middlewares.get(routeId) ?? [];
+      this.middlewares.set(routeId, [...existing, m.handler]);
+    }
+  }
+  find(routeId) {
+    const globals = this.middlewares.get("*") ?? [];
+    const locals = this.middlewares.get(routeId) ?? [];
+    return compile([...globals, ...locals]);
+  }
+  static resolveRouteIds(m) {
+    if (m.useOn === "*")
+      return { isGlobal: true };
+    const targets = Array.isArray(m.useOn) ? m.useOn : [m.useOn];
+    const routeIds = [];
+    for (const target of targets) {
+      if (target instanceof Route) {
+        routeIds.push(target.id);
+      } else if (target instanceof ControllerAbstract) {
+        routeIds.push(...target.routeIds);
+      }
+    }
+    return { isGlobal: false, routeIds };
   }
-  findRoute(req) {
-    const reqPath = req.urlObject.pathname;
-    const reqMethod = req.method;
+}
+
+// src/Router/adapters/CorpusAdapter.ts
+class CorpusAdapter {
+  routes = new Map;
+  modelRegistry = new ModelRegistry;
+  middlewareRegistry = new MiddlewareRegistry;
+  addRoute(data) {
+    this.checkPossibleCollision(data);
+    this.routes.set(data.id, data);
+  }
+  addModel(route, model) {
+    this.modelRegistry.add(route.method, route.endpoint, model);
+  }
+  addMiddleware(middleware) {
+    this.middlewareRegistry.add(middleware);
+  }
+  find(req) {
+    const method = req.method;
+    const pathname = req.urlObject.pathname;
+    const searchParams = req.urlObject.searchParams;
     let route = null;
-    for (const [endpoint, data] of this.routes.entries()) {
-      if (endpoint.includes(":")) {
-        if (isRegexMatch(reqPath, data.pattern)) {
-          route = data;
-          break;
-        }
-        if (this.hasLastPartParam(endpoint) && strIsEqual(endpoint.split("/").slice(0, -1).join("/"), reqPath, "lower")) {
-          route = data;
-          break;
-        }
-      } else if (strIsEqual(endpoint, reqPath)) {
+    for (const data of this.routes.values()) {
+      if (this.hasAnyParam(data.endpoint) && isRegexMatch(pathname, data.pattern)) {
+        route = data;
+        break;
+      }
+      if (this.hasLastPartParam(data.endpoint) && strIsEqual(this.removeLastParam(data.endpoint), pathname, "lower")) {
+        route = data;
+        break;
+      }
+      if (strIsEqual(data.endpoint, pathname)) {
         route = data;
         break;
       }
     }
     if (route === null) {
-      throw HttpError.notFound();
+      throw CError.notFound();
     }
-    if (!strIsEqual(reqMethod, route.method, "upper")) {
-      throw HttpError.methodNotAllowed();
+    if (!strIsEqual(method, route.method, "upper")) {
+      throw CError.methodNotAllowed();
     }
-    return route;
+    return {
+      route,
+      model: this.modelRegistry.find(route.id),
+      middleware: this.middlewareRegistry.find(route.id),
+      params: this.extractParams(pathname, route.endpoint),
+      search: Object.fromEntries(searchParams)
+    };
   }
-  checkPossibleCollision(r) {
-    const existingById = this.routes.get(r.id);
-    if (existingById) {
-      console.error(`\u26A0\uFE0F  Collision: ${r.method} ${r.endpoint} clashes with ${existingById.method} ${existingById.endpoint}`);
-    }
-    for (const existing of this.routes.values()) {
-      if (existing.method !== r.method)
+  list() {
+    return Array.from(this.routes.values());
+  }
+  checkPossibleCollision(n) {
+    const dupeMsg = (nId) => console.error(`Duplicate route detected. ${nId} has already been registered.`);
+    const dynamicPatternMsg = (nId, oId) => console.error(`Ambiguous dynamic routes. ${nId} and ${oId} match the same URL patterns.`);
+    const baseDupeMsg = (nId, oId) => console.error(`Dynamic route overlaps existing route. ${nId} \u2014 dropping the last param segment matches ${oId}.`);
+    const shadowMsg = (nId, oId) => console.error(`Route shadowed by existing dynamic route. ${nId} will be unreachable \u2014 ${oId} captures the same URL space.`);
+    const existing = this.routes.get(n.id);
+    if (existing) {
+      dupeMsg(n.id);
+      return true;
+    }
+    const nHasAnyParam = this.hasAnyParam(n.endpoint);
+    const nHasLastPartParam = this.hasLastPartParam(n.endpoint);
+    for (const o of this.routes.values()) {
+      if (o.method !== n.method)
         continue;
-      if (this.hasAnyParam(r.endpoint)) {
-        if (isRegexMatch(r.endpoint, existing.pattern)) {
-          console.error(`\u26A0\uFE0F  Collision: ${r.method} ${r.endpoint} clashes with ${existing.method} ${existing.endpoint}`);
+      if (nHasAnyParam) {
+        if (isRegexMatch(n.endpoint, o.pattern) || isRegexMatch(o.endpoint, n.pattern)) {
+          dynamicPatternMsg(n.id, o.id);
+          return true;
         }
-        if (!this.hasAnyParam(existing.endpoint)) {
-          if (strIsEqual(this.removeLastParam(r.endpoint), existing.endpoint, "lower")) {
-            console.error(`\u26A0\uFE0F  Param route ${r.method} ${r.endpoint} may conflict with static ${existing.method} ${existing.endpoint}`);
-          }
-        }
-      } else {
-        if (strIsEqual(r.endpoint, existing.endpoint, "lower")) {
-          console.error(`\u26A0\uFE0F  Collision: ${r.method} ${r.endpoint} already exists`);
+      }
+      if (nHasLastPartParam) {
+        if (isRegexMatch(this.removeLastParam(n.endpoint), o.pattern)) {
+          baseDupeMsg(n.id, o.id);
+          return true;
         }
-        if (this.hasLastPartParam(existing.endpoint)) {
-          if (strIsEqual(this.removeLastParam(r.endpoint), this.removeLastParam(existing.endpoint), "lower")) {
-            console.error(`\u26A0\uFE0F  Static route ${r.method} ${r.endpoint} may be shadowed by param route ${existing.method} ${existing.endpoint}`);
-          }
+      }
+      const oHasLastPartParam = this.hasLastPartParam(o.endpoint);
+      if (oHasLastPartParam) {
+        if (isRegexMatch(n.endpoint, Route.makeRoutePattern(this.removeLastParam(o.endpoint)))) {
+          shadowMsg(n.id, o.id);
+          return true;
         }
       }
     }
+    return false;
+  }
+  extractParams(pathname, endpoint) {
+    const data = {};
+    if (!this.hasAnyParam(endpoint))
+      return data;
+    const defParts = endpoint.split("/");
+    const reqParts = pathname.split("/");
+    for (const [i, defPart] of defParts.entries()) {
+      const reqPart = reqParts[i];
+      if (defPart.startsWith(":") && reqPart !== undefined) {
+        data[defPart.slice(1)] = decodeURIComponent(reqPart);
+      }
+    }
+    return data;
   }
   hasLastPartParam(endpoint) {
     if (!this.hasAnyParam(endpoint))
@@ -1252,94 +1398,83 @@ class Router {
     return endpoint.split("/").slice(0, -1).join("/");
   }
   hasAnyParam(endpoint) {
-    return endpoint.includes(":");
-  }
-  compile(fns) {
-    return async (...args) => {
-      for (const fn of fns) {
-        if (!fn)
-          continue;
-        await fn(...args);
-      }
-    };
-  }
-  intern(value, ...namespace) {
-    const key = namespace.join("::");
-    const existing = this.internFuncMap.get(key);
-    if (existing)
-      return existing;
-    this.internFuncMap.set(key, value);
-    return value;
+    if (endpoint.includes("/:"))
+      return true;
+    if (!endpoint.includes(":"))
+      return false;
+    return endpoint.split("/").some((p) => p.startsWith(":"));
   }
 }
 
-// src/utils/boolToString.ts
-function boolToString(arg) {
-  return arg ? "true" : "false";
-}
-
-// src/utils/isSomeArray.ts
-function isSomeArray(arg) {
-  return arg !== undefined && Array.isArray(arg) && arg.length > 0 && arg.every((a) => a !== null && a !== undefined);
-}
-
-// src/Cors/Cors.ts
-class Cors {
-  opts;
-  constructor(opts) {
-    this.opts = opts;
+// src/Router/Router.ts
+class Router {
+  constructor(adapter) {
+    this._adapter = adapter ?? new CorpusAdapter;
   }
-  originKey = "Access-Control-Allow-Origin";
-  methodsKey = "Access-Control-Allow-Methods";
-  headersKey = "Access-Control-Allow-Headers";
-  credentialsKey = "Access-Control-Allow-Credentials";
-  getCorsHeaders(req, res) {
-    const reqOrigin = req.headers.get("origin") ?? "";
-    const { allowedOrigins, allowedMethods, allowedHeaders, credentials } = this.opts;
-    if (isSomeArray(allowedOrigins) && allowedOrigins.includes(reqOrigin)) {
-      res.headers.set(this.originKey, reqOrigin);
-    }
-    if (isSomeArray(allowedMethods)) {
-      res.headers.set(this.methodsKey, allowedMethods.join(", "));
-    }
-    if (isSomeArray(allowedHeaders)) {
-      res.headers.set(this.headersKey, allowedHeaders.join(", "));
+  models = [];
+  _adapter;
+  cache = new WeakMap;
+  checkPossibleCollision(n) {
+    if (this._adapter instanceof CorpusAdapter) {
+      return this._adapter.checkPossibleCollision(n);
     }
-    res.headers.set(this.credentialsKey, boolToString(credentials));
-    return res.headers;
+    return false;
   }
-  apply(req, res) {
-    const headers = this.getCorsHeaders(req, res);
-    res.headers.innerCombine(headers);
+  addModel(route, model) {
+    this.models.push(model);
+    this._adapter.addModel(route, model);
+  }
+  addMiddleware(middleware) {
+    this._adapter.addMiddleware(middleware);
+  }
+  addRoute(r) {
+    this._adapter.addRoute({
+      id: r.id,
+      endpoint: r.endpoint,
+      method: r.method,
+      handler: r.handler,
+      pattern: r.pattern
+    });
+  }
+  findRouteHandler(req) {
+    const cached = this.cache.get(req);
+    if (cached)
+      return cached;
+    const match = this._adapter.find(req);
+    if (!match)
+      throw CError.notFound();
+    const ctx = Context.makeFromRequest(req);
+    const handler = async () => {
+      await match.middleware?.(ctx);
+      await Context.appendParsedData(ctx, req, match.params, match.search, match.model);
+      const res = await match.route.handler(ctx);
+      return res instanceof CResponse ? res : new CResponse(res, {
+        cookies: ctx.res.cookies,
+        headers: ctx.res.headers,
+        status: ctx.res.status,
+        statusText: ctx.res.statusText
+      });
+    };
+    this.cache.set(req, handler);
+    return handler;
+  }
+  getRouteList() {
+    return this._adapter.list().map((v) => [v.method, v.endpoint]);
   }
 }
 
 // src/Server/ServerAbstract.ts
 class ServerAbstract {
-  cors;
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    _routerStore.set(new Router(opts?.adapter));
+  }
   get routes() {
-    return getRouterInstance().getRouteList();
+    return _routerStore.get().getRouteList();
   }
   setGlobalPrefix(value) {
-    Config.set(_globalPrefixEnvKey, value);
-  }
-  setCors(cors) {
-    this.cors = new Cors(cors);
-  }
-  setOnError(handler) {
-    this.handleError = handler;
-  }
-  setOnNotFound(handler) {
-    this.handleNotFound = handler;
-  }
-  setOnBeforeListen(handler) {
-    this.handleBeforeListen = handler;
-  }
-  setOnBeforeClose(handler) {
-    this.handleBeforeClose = handler;
-  }
-  setOnAfterResponse(handler) {
-    this.handleAfterResponse = handler;
+    _prefixStore.set(value);
   }
   async listen(port, hostname = "0.0.0.0") {
     try {
@@ -1358,10 +1493,11 @@ class ServerAbstract {
     }
   }
   async handle(request) {
-    const req = new HttpRequest(request);
+    const req = new CRequest(request);
     let res = await this.getResponse(req);
-    if (this.cors !== undefined) {
-      this.cors.apply(req, res);
+    const cors = _corsStore.get();
+    if (cors !== null) {
+      cors.apply(req, res);
     }
     if (this.handleAfterResponse) {
       res = await this.handleAfterResponse(res);
@@ -1371,12 +1507,12 @@ class ServerAbstract {
   async getResponse(req) {
     try {
       if (req.isPreflight) {
-        return new HttpResponse("Departed");
+        return new CResponse("Departed");
       }
-      const handler = getRouterInstance().getRouteHandler(req);
+      const handler = _routerStore.get().findRouteHandler(req);
       return await handler();
     } catch (err) {
-      if (err instanceof HttpError) {
+      if (err instanceof CError) {
         if (err.isStatusOf(Status.NOT_FOUND)) {
           return await this.handleNotFound(req);
         }
@@ -1388,39 +1524,56 @@ class ServerAbstract {
     }
   }
   handleBeforeListen;
+  setOnBeforeListen(handler) {
+    this.handleBeforeListen = handler;
+  }
+  defaultOnBeforeListen = undefined;
   handleBeforeClose;
+  setOnBeforeClose(handler) {
+    this.handleBeforeClose = handler;
+  }
+  defaultOnBeforeClose = undefined;
   handleAfterResponse;
-  handleError = async (err) => {
+  setOnAfterResponse(handler) {
+    this.handleAfterResponse = handler;
+  }
+  defaultOnAfterResponse = undefined;
+  handleError = (err) => this.defaultErrorHandler(err);
+  setOnError(handler) {
+    this.handleError = handler;
+  }
+  defaultErrorHandler = (err) => {
     if (!(err instanceof Error)) {
-      return new HttpResponse({ error: err, message: "Unknown" }, { status: Status.INTERNAL_SERVER_ERROR });
+      return new CResponse({ error: err, message: "Unknown" }, { status: Status.INTERNAL_SERVER_ERROR });
     }
-    if (err instanceof HttpError) {
+    if (err instanceof CError) {
       return err.toResponse();
     }
-    return new HttpResponse({ error: err, message: err.message }, { status: Status.INTERNAL_SERVER_ERROR });
+    return new CResponse({ error: err, message: err.message }, { status: Status.INTERNAL_SERVER_ERROR });
   };
-  handleNotFound = async (req) => {
-    return new HttpResponse({ error: true, message: `${req.method} on ${req.url} does not exist.` }, { status: Status.NOT_FOUND });
+  handleNotFound = (req) => this.defaultNotFoundHandler(req);
+  setOnNotFound(handler) {
+    this.handleNotFound = handler;
+  }
+  defaultNotFoundHandler = (req) => {
+    return new CResponse({ error: true, message: `${req.method} on ${req.url} does not exist.` }, { status: Status.NOT_FOUND });
   };
-  handleMethodNotAllowed = async (req) => {
-    return new HttpResponse({ error: `${req.method} does not exist.` }, { status: Status.METHOD_NOT_ALLOWED });
+  handleMethodNotAllowed = (req) => this.defaultMethodNotFoundHandler(req);
+  defaultMethodNotFoundHandler = (req) => {
+    return new CResponse({ error: `${req.method} ${req.url} does not exist.` }, { status: Status.METHOD_NOT_ALLOWED });
   };
 }
 
 // src/Server/ServerUsingBun.ts
 class ServerUsingBun extends ServerAbstract {
   app;
-  constructor() {
-    super();
-    setRouterInstance(new Router);
-  }
-  serve(options) {
-    this.app = this.createApp(options);
+  serve(args) {
+    this.app = this.createApp(args);
   }
   async close() {
     await this.handleBeforeClose?.();
     console.log("Closing...");
-    await this.app?.stop();
+    await this.app?.stop(true);
     if (Config.nodeEnv !== "test") {
       process.exit(0);
     }
@@ -1429,7 +1582,9 @@ class ServerUsingBun extends ServerAbstract {
     return Bun.serve({
       port: options.port,
       hostname: options.hostname,
-      fetch: options.fetch
+      fetch: options.fetch,
+      idleTimeout: this.opts?.idleTimeout,
+      tls: this.opts?.tls
     });
   }
 }
@@ -1437,41 +1592,371 @@ class ServerUsingBun extends ServerAbstract {
 // src/Server/Server.ts
 class Server extends ServerUsingBun {
 }
-// src/index.ts
-var RouterInstance;
-function getRouterInstance() {
-  if (!RouterInstance) {
-    console.error("Router instance is not set. Please instantiate your Server before your routes.");
-    process.exit(1);
+// src/X.ts
+var exports_X = {};
+__export(exports_X, {
+  Repository: () => RepositoryAbstract,
+  Parser: () => Parser,
+  MemoiristAdapter: () => MemoiristAdapter,
+  File: () => XFile,
+  Cors: () => Cors
+});
+// src/utils/boolToString.ts
+function boolToString(arg) {
+  return arg ? "true" : "false";
+}
+
+// src/utils/isSomeArray.ts
+function isSomeArray(arg) {
+  return arg !== undefined && Array.isArray(arg) && arg.length > 0 && arg.every((a) => a !== null && a !== undefined);
+}
+
+// src/Cors/Cors.ts
+class Cors {
+  opts;
+  constructor(opts) {
+    this.opts = opts;
+    if (opts === undefined) {
+      _corsStore.set(null);
+    } else {
+      _corsStore.set(this);
+    }
+  }
+  originKey = "Access-Control-Allow-Origin";
+  methodsKey = "Access-Control-Allow-Methods";
+  headersKey = "Access-Control-Allow-Headers";
+  credentialsKey = "Access-Control-Allow-Credentials";
+  getCorsHeaders(req, res) {
+    const reqOrigin = req.headers.get("origin") ?? "";
+    const { allowedOrigins, allowedMethods, allowedHeaders, credentials } = this.opts ?? {};
+    if (isSomeArray(allowedOrigins) && allowedOrigins.includes(reqOrigin)) {
+      res.headers.set(this.originKey, reqOrigin);
+    }
+    if (isSomeArray(allowedMethods)) {
+      res.headers.set(this.methodsKey, allowedMethods.join(", "));
+    }
+    if (isSomeArray(allowedHeaders)) {
+      res.headers.set(this.headersKey, allowedHeaders.join(", "));
+    }
+    res.headers.set(this.credentialsKey, boolToString(credentials));
+    return res.headers;
+  }
+  apply(req, res) {
+    const headers = this.getCorsHeaders(req, res);
+    res.headers.innerCombine(headers);
+  }
+}
+// src/Repository/RepositoryAbstract.ts
+class RepositoryAbstract {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+}
+// node_modules/memoirist/dist/bun/index.js
+var Y = (v, b) => {
+  let A = b?.length ? {} : null;
+  if (A)
+    for (let Q of b)
+      A[Q.part.charCodeAt(0)] = Q;
+  return { part: v, store: null, inert: A, params: null, wildcardStore: null };
+};
+var k = (v, b) => ({ ...v, part: b });
+var T = (v) => ({ name: v, store: null, inert: null });
+
+class _ {
+  config;
+  root = {};
+  history = [];
+  deferred = [];
+  constructor(v = {}) {
+    this.config = v;
+    if (v.lazy)
+      this.find = this.lazyFind;
+    if (v.onParam && !Array.isArray(v.onParam))
+      this.config.onParam = [this.config.onParam];
+  }
+  static regex = { static: /:.+?(?=\/|$)/, params: /:.+?(?=\/|$)/g, optionalParams: /(\/:\w+\?)/g };
+  lazyFind = (v, b) => {
+    if (!this.config.lazy)
+      return this.find;
+    return this.build(), this.find(v, b);
+  };
+  build() {
+    if (!this.config.lazy)
+      return;
+    for (let [v, b, A] of this.deferred)
+      this.add(v, b, A, { lazy: false, ignoreHistory: true });
+    this.deferred = [], this.find = (v, b) => {
+      let A = this.root[v];
+      if (!A)
+        return null;
+      return $(b, b.length, A, 0, this.config.onParam);
+    };
+  }
+  add(v, b, A, { ignoreError: Q = false, ignoreHistory: O = false, lazy: V = this.config.lazy } = {}) {
+    if (V)
+      return this.find = this.lazyFind, this.deferred.push([v, b, A]), A;
+    if (typeof b !== "string")
+      throw new TypeError("Route path must be a string");
+    if (b === "")
+      b = "/";
+    else if (b[0] !== "/")
+      b = `/${b}`;
+    let X = b[b.length - 1] === "*", J = b.match(_.regex.optionalParams);
+    if (J) {
+      let F = b.replaceAll("?", "");
+      this.add(v, F, A, { ignoreError: Q, ignoreHistory: O, lazy: V });
+      for (let B = 0;B < J.length; B++) {
+        let D = b.replace(J[B], "");
+        this.add(v, D, A, { ignoreError: true, ignoreHistory: O, lazy: V });
+      }
+      return A;
+    }
+    if (J)
+      b = b.replaceAll("?", "");
+    if (this.history.find(([F, B, D]) => F === v && B === b))
+      return A;
+    if (X || J && b.charCodeAt(b.length - 1) === 63)
+      b = b.slice(0, -1);
+    if (!O)
+      this.history.push([v, b, A]);
+    let K = b.split(_.regex.static), G = b.match(_.regex.params) || [];
+    if (K[K.length - 1] === "")
+      K.pop();
+    let q;
+    if (!this.root[v])
+      q = this.root[v] = Y("/");
+    else
+      q = this.root[v];
+    let U = 0;
+    for (let F = 0;F < K.length; ++F) {
+      let B = K[F];
+      if (F > 0) {
+        let D = G[U++].slice(1);
+        if (q.params === null)
+          q.params = T(D);
+        else if (q.params.name !== D)
+          if (Q)
+            return A;
+          else
+            throw new Error(`Cannot create route "${b}" with parameter "${D}" because a route already exists with a different parameter name ("${q.params.name}") in the same location`);
+        let S = q.params;
+        if (S.inert === null) {
+          q = S.inert = Y(B);
+          continue;
+        }
+        q = S.inert;
+      }
+      for (let D = 0;; ) {
+        if (D === B.length) {
+          if (D < q.part.length) {
+            let S = k(q, q.part.slice(D));
+            Object.assign(q, Y(B, [S]));
+          }
+          break;
+        }
+        if (D === q.part.length) {
+          if (q.inert === null)
+            q.inert = {};
+          let S = q.inert[B.charCodeAt(D)];
+          if (S) {
+            q = S, B = B.slice(D), D = 0;
+            continue;
+          }
+          let Z = Y(B.slice(D));
+          q.inert[B.charCodeAt(D)] = Z, q = Z;
+          break;
+        }
+        if (B[D] !== q.part[D]) {
+          let S = k(q, q.part.slice(D)), Z = Y(B.slice(D));
+          Object.assign(q, Y(q.part.slice(0, D), [S, Z])), q = Z;
+          break;
+        }
+        ++D;
+      }
+    }
+    if (U < G.length) {
+      let B = G[U].slice(1);
+      if (q.params === null)
+        q.params = T(B);
+      else if (q.params.name !== B)
+        if (Q)
+          return A;
+        else
+          throw new Error(`Cannot create route "${b}" with parameter "${B}" because a route already exists with a different parameter name ("${q.params.name}") in the same location`);
+      if (q.params.store === null)
+        q.params.store = A;
+      return q.params.store;
+    }
+    if (X) {
+      if (q.wildcardStore === null)
+        q.wildcardStore = A;
+      return q.wildcardStore;
+    }
+    if (q.store === null)
+      q.store = A;
+    return q.store;
+  }
+  find(v, b) {
+    let A = this.root[v];
+    if (!A)
+      return null;
+    return $(b, b.length, A, 0, this.config.onParam);
   }
-  return RouterInstance;
 }
-function setRouterInstance(router) {
-  RouterInstance = router;
+var $ = (v, b, A, Q, O) => {
+  let V = A.part, X = V.length, J = Q + X;
+  if (X > 1) {
+    if (J > b)
+      return null;
+    if (X < 15) {
+      for (let K = 1, G = Q + 1;K < X; ++K, ++G)
+        if (V.charCodeAt(K) !== v.charCodeAt(G))
+          return null;
+    } else if (v.slice(Q, J) !== V)
+      return null;
+  }
+  if (J === b) {
+    if (A.store !== null)
+      return { store: A.store, params: {} };
+    if (A.wildcardStore !== null)
+      return { store: A.wildcardStore, params: { "*": "" } };
+    return null;
+  }
+  if (A.inert !== null) {
+    let K = A.inert[v.charCodeAt(J)];
+    if (K !== undefined) {
+      let G = $(v, b, K, J, O);
+      if (G !== null)
+        return G;
+    }
+  }
+  if (A.params !== null) {
+    let { store: K, name: G, inert: q } = A.params, U = v.indexOf("/", J);
+    if (U !== J) {
+      if (U === -1 || U >= b) {
+        if (K !== null) {
+          let F = {};
+          if (F[G] = v.substring(J, b), O)
+            for (let B = 0;B < O.length; B++) {
+              let D = O[B](F[G], G);
+              if (D !== undefined)
+                F[G] = D;
+            }
+          return { store: K, params: F };
+        }
+      } else if (q !== null) {
+        let F = $(v, b, q, U, O);
+        if (F !== null) {
+          if (F.params[G] = v.substring(J, U), O)
+            for (let B = 0;B < O.length; B++) {
+              let D = O[B](F.params[G], G);
+              if (D !== undefined)
+                F.params[G] = D;
+            }
+          return F;
+        }
+      }
+    }
+  }
+  if (A.wildcardStore !== null)
+    return { store: A.wildcardStore, params: { "*": v.substring(J, b) } };
+  return null;
+};
+var w = _;
+
+// src/Router/adapters/MemoiristAdapter.ts
+class MemoiristAdapter {
+  router = new w;
+  pendingMiddlewares = new Map;
+  find(req) {
+    const method = req.method;
+    const pathname = req.urlObject.pathname;
+    const searchParams = req.urlObject.searchParams;
+    const result = this.router.find(method, pathname);
+    if (!result)
+      return null;
+    return {
+      route: result.store.route,
+      model: result.store.model,
+      params: result.params,
+      search: Object.fromEntries(searchParams),
+      middleware: compile(result.store.middlewares ?? [])
+    };
+  }
+  list() {
+    return this.router.history.map((v) => v[2].route);
+  }
+  addRoute(data) {
+    this.router.add(data.method, data.endpoint, { route: data });
+    const pending = this.pendingMiddlewares.get(data.id);
+    if (pending) {
+      const store = this.router.find(data.method, data.endpoint)?.store;
+      if (store)
+        store.middlewares = pending;
+      this.pendingMiddlewares.delete(data.id);
+    }
+  }
+  addModel(route, model) {
+    const result = this.router.find(route.method, route.endpoint);
+    if (!result)
+      return;
+    result.store.model = ModelRegistry.toRouterModelData(model);
+  }
+  addMiddleware(middleware) {
+    const resolved = MiddlewareRegistry.resolveRouteIds(middleware);
+    if (resolved.isGlobal) {
+      for (const [, , store] of this.router.history) {
+        store.middlewares = [...store.middlewares ?? [], middleware.handler];
+      }
+      return;
+    }
+    for (const routeId of resolved.routeIds) {
+      const [method, endpoint] = routeId.split(" ", 2);
+      const result = this.router.find(method, endpoint);
+      if (result) {
+        result.store.middlewares = [
+          ...result.store.middlewares ?? [],
+          middleware.handler
+        ];
+      } else {
+        const pending = this.pendingMiddlewares.get(routeId) ?? [];
+        this.pendingMiddlewares.set(routeId, [...pending, middleware.handler]);
+      }
+    }
+  }
 }
-var src_default = exports_exports;
+// src/index.ts
+var _prefixStore = new GlobalPrefixStore;
+var _routerStore = new GlobalRouterStore;
+var _corsStore = new GlobalCorsStore;
 export {
-  setRouterInstance,
-  getRouterInstance,
-  src_default as default,
+  exports_C as default,
+  _routerStore,
+  _prefixStore,
+  _corsStore,
+  exports_X as X,
   Status,
   StaticRoute,
   Server,
   Route,
-  HttpResponse as Response,
-  HttpRequest as Request,
+  CResponse as Response,
+  CRequest as Request,
   RepositoryAbstract as Repository,
   Parser,
   Middleware,
   Method,
-  HttpHeaders as Headers,
-  FileWalker,
-  HttpError as Error,
-  DefaultStatusTexts,
+  MemoiristAdapter,
+  CHeaders as Headers,
+  XFile as File,
+  exports_X as Extra,
+  CError as Error,
+  Cors,
   Cookies,
   ControllerAbstract as Controller,
   Context,
   Config,
   CommonHeaders,
-  exports_exports as C
+  exports_C as C
 };