@ozanarslan/corpus 0.1.6 → 0.1.9

package/dist/index.d.ts

@@ -10,6 +10,11 @@ declare abstract class StoreAbstract<T> {
 declare class GlobalPrefixStore extends StoreAbstract<string> {
 	protected value: string;
 }
+export type _Default = typeof _Default;
+declare const _Default: unique symbol;
+export type ConstructorOf<A extends abstract new (...args: any) => any, I = _Default> = {
+	new (...args: ConstructorParameters<A>): I extends _Default ? InstanceType<A> : I;
+};
 export type CookieOptions = {
 	name: string;
 	value: string;
@@ -26,7 +31,11 @@ export type CookieOptions = {
 };
 export type CookiesInit = CookiesAbstract | CookieOptions | CookieOptions[];
 declare abstract class CookiesAbstract {
-	protected abstract map: Bun.CookieMap | Map<string, string>;
+	constructor(_?: CookiesInit);
+	protected abstract map: Iterable<[
+		string,
+		string
+	]>;
 	abstract set(opts: CookieOptions): void;
 	abstract get(name: string): string | null;
 	abstract has(name: string): boolean;
@@ -42,12 +51,8 @@ declare abstract class CookiesAbstract {
 	abstract setMany(optsArr: Array<CookieOptions>): void;
 	protected applyInit(init?: CookiesInit): void;
 }
-declare class CookiesUsingBun extends CookiesAbstract {
-	constructor(init?: CookiesInit);
-	protected map: Bun.CookieMap;
-	toSetCookieHeaders(): Array<string>;
+export interface CookiesInterface {
 	set(opts: CookieOptions): void;
-	setMany(optsArr: Array<CookieOptions>): void;
 	get(name: string): string | null;
 	has(name: string): boolean;
 	get count(): number;
@@ -58,8 +63,11 @@ declare class CookiesUsingBun extends CookiesAbstract {
 	]>;
 	values(): Array<string>;
 	keys(): Array<string>;
+	toSetCookieHeaders(): Array<string>;
+	setMany(optsArr: Array<CookieOptions>): void;
 }
-export declare class Cookies extends CookiesUsingBun {
+declare const Adapted: ConstructorOf<typeof CookiesAbstract, CookiesInterface>;
+export declare class Cookies extends Adapted {
 }
 export type ValueOf<T> = T[keyof T];
 /** Just some common headers. */
@@ -86,6 +94,7 @@ export declare const CommonHeaders: {
 	readonly Referer: "Referer";
 	/** Indicates whether the connection should be kept alive */
 	readonly Connection: "Connection";
+	readonly Upgrade: "Upgrade";
 	/** Used to specify directives that must be obeyed by caching mechanisms */
 	readonly Pragma: "Pragma";
 	/** The date and time at which the message was sent */
@@ -163,6 +172,7 @@ declare class CRequest extends Request {
 	constructor(info: CRequestInfo, init?: CRequestInit | undefined);
 	readonly urlObject: URL;
 	readonly isPreflight: boolean;
+	readonly isWebsocket: boolean;
 	readonly cookies: Cookies;
 	headers: CHeaders;
 	private resolveUrlObject;
@@ -170,6 +180,7 @@ declare class CRequest extends Request {
 	/** Gets cookie header and collects cookies for the jar */
 	private resolveCookies;
 	private resolveIsPreflight;
+	private resolveIsWebsocketUpgrade;
 }
 export type OrNumber<T> = T | (number & {});
 /** Commonly used HTTP status codes. */
@@ -356,9 +367,9 @@ export type NdjsonSource = Func<[
  * - {@link CResponse.file} — Respond with a static file
  */
 declare class CResponse<R = unknown> {
-	protected readonly data?: CResponseBody<R>;
-	protected readonly init?: CResponseInit | undefined;
-	constructor(data?: CResponseBody<R>, init?: CResponseInit | undefined);
+	data?: CResponseBody<R>;
+	protected readonly init?: (CResponseInit | CResponse) | undefined;
+	constructor(data?: CResponseBody<R>, init?: (CResponseInit | CResponse) | undefined);
 	body: BodyInit;
 	headers: CHeaders;
 	status: Status;
@@ -379,17 +390,8 @@ declare class CResponse<R = unknown> {
 	private resolveStatus;
 	private setContentType;
 	private resolveBody;
-	private getDefaultStatusText;
+	static getDefaultStatusText(status: number): string;
 }
-declare const RouteVariant: {
-	readonly static: "static";
-	readonly dynamic: "dynamic";
-};
-export type RouteVariant = ValueOf<typeof RouteVariant>;
-export type RouteDefinition<Path extends string = string> = {
-	method: Method;
-	path: Path;
-} | Path;
 export interface DatabaseClientInterface {
 }
 export interface ContextDataInterface {
@@ -559,9 +561,8 @@ export declare class Context<B = unknown, S = unknown, P = unknown, R = unknown>
 }
 export type MaybePromise<T> = Promise<T> | T;
 export type RouteHandler<B = unknown, S = unknown, P = unknown, R = unknown> = Func<[
-	Context<B, S, P, R>
+	context: Context<B, S, P, R>
 ], MaybePromise<R>>;
-export type RouteId = `${string} ${string}`;
 export interface Schema<T = unknown> extends StandardSchemaV1<unknown, T> {
 }
 export type RouteModel<B = unknown, S = unknown, P = unknown, R = unknown> = {
@@ -570,7 +571,42 @@ export type RouteModel<B = unknown, S = unknown, P = unknown, R = unknown> = {
 	search?: Schema<S>;
 	params?: Schema<P>;
 };
-declare abstract class RouteAbstract<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown> {
+declare const RouteVariant: {
+	readonly static: "static";
+	readonly dynamic: "dynamic";
+	readonly websocket: "websocket";
+};
+export type RouteVariant = ValueOf<typeof RouteVariant>;
+export type RouteId = `${string} ${string}`;
+export interface RouteInterface<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown> {
+	variant: RouteVariant;
+	id: RouteId;
+	method: OrString<Method>;
+	endpoint: Path;
+	pattern: RegExp;
+	handler: RouteHandler<B, S, P, R>;
+	model?: RouteModel<B, S, P, R>;
+}
+export type AnyRoute = RouteInterface<string, any, any, any, any>;
+export type RouterRouteData = Pick<AnyRoute, "id" | "endpoint" | "method" | "pattern" | "handler" | "variant">;
+export type RouterReturnData = {
+	route: RouterRouteData;
+	params: Record<string, string>;
+	search: Record<string, string>;
+};
+export interface RouterAdapterInterface {
+	find(req: CRequest): RouterReturnData | null;
+	list(): Array<RouterRouteData>;
+	add(data: RouterRouteData): void;
+}
+export type MiddlewareHandler = Func<[
+	Context
+], MaybePromise<void>>;
+export type DynamicRouteDefinition<Path extends string = string> = {
+	method: Method;
+	path: Path;
+} | Path;
+declare abstract class RouteAbstract<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown> implements RouteInterface<Path, B, S, P, R> {
 	abstract variant: RouteVariant;
 	abstract endpoint: Path;
 	abstract method: OrString<Method>;
@@ -578,13 +614,18 @@ declare abstract class RouteAbstract<Path extends string = string, B = unknown,
 	abstract id: RouteId;
 	abstract handler: RouteHandler<B, S, P, R>;
 	abstract model?: RouteModel<B, S, P, R>;
-	protected resolveEndpoint(definition: RouteDefinition<Path>, variant: RouteVariant): Path;
-	protected resolveMethod(definition: RouteDefinition<Path>): Method;
 	protected resolvePattern(endpoint: Path): RegExp;
 	protected resolveId(method: string, endpoint: Path): RouteId;
+	static makeRouteId(method: string, endpoint: string): RouteId;
+	static makeRoutePattern(endpoint: string): RegExp;
+}
+export declare abstract class DynamicRouteAbstract<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown> extends RouteAbstract<Path, B, S, P, R> {
+	variant: RouteVariant;
+	protected resolveEndpoint(definition: DynamicRouteDefinition<Path>): Path;
+	protected resolveMethod(definition: DynamicRouteDefinition<Path>): Method;
 }
 /**
- * Defines an HTTP endpoint. Accepts a {@link RouteDefinition} which can either be a plain
+ * Defines an HTTP endpoint. Accepts a {@link DynamicRouteDefinition} which can either be a plain
  * path string (defaults to GET) or an object with a `method` and `path` for other HTTP methods.
  *
  * The handler receives a {@link Context} and can return any data, a {@link CResponse} directly,
@@ -606,66 +647,42 @@ declare abstract class RouteAbstract<Path extends string = string, B = unknown,
  *     return { created: c.body.name };
  * }, { body: UserModel });
  */
-export declare class Route<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown> extends RouteAbstract<Path, B, S, P, R> {
-	constructor(definition: RouteDefinition<Path>, handler: RouteHandler<B, S, P, R>, model?: RouteModel<B, S, P, R>);
-	variant: RouteVariant;
-	endpoint: Path;
+declare class DynamicRoute<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown> extends DynamicRouteAbstract<Path, B, S, P, R> {
+	constructor(definition: DynamicRouteDefinition<Path>, handler: RouteHandler<B, S, P, R>, model?: RouteModel<B, S, P, R>);
+	id: RouteId;
 	method: OrString<Method>;
+	endpoint: Path;
 	pattern: RegExp;
-	id: RouteId;
 	handler: RouteHandler<B, S, P, R>;
-	model?: RouteModel<B, S, P, R> | undefined;
-	static makeRouteId(method: string, endpoint: string): RouteId;
-	static makeRoutePattern(endpoint: string): RegExp;
+	model?: RouteModel<B, S, P, R>;
 }
-export type AnyRoute = Route<string, any, any, any, any>;
-export type MiddlewareHandler = Func<[
-	Context
-], MaybePromise<void>>;
+export type R = string | CResponse;
 export type StaticRouteHandler<B = unknown, S = unknown, P = unknown> = Func<[
-	context: Context<B, S, P, string | CResponse>,
+	context: Context<B, S, P, R>,
 	content: string
-], MaybePromise<string | CResponse>>;
+], MaybePromise<R>>;
 export type StaticRouteDefinition = string | {
 	filePath: string;
 	stream: true;
 	disposition?: "attachment" | "inline";
 };
-/**
- * Defines a route that serves a static file. Accepts a path and a {@link StaticRouteDefinition}
- * which can either be a plain file path string for a standard file response, or an object
- * with `stream: true` to stream the file directly from disk — useful for large files like
- * videos, PDFs, or large assets where reading the entire file into memory is undesirable.
- *
- * An optional custom handler can be provided to intercept the file content before it is sent,
- * for example to modify headers or transform the content. Route instantiation automatically
- * registers to the router.
- *
- * @example
- * // Serve a file normally
- * new StaticRoute("/style", "assets/style.css");
- *
- * // Stream a large file
- * new StaticRoute("/video", { filePath: "assets/video.mp4", stream: true });
- *
- * // Custom handler
- * new StaticRoute("/doc", "assets/doc.txt", (c, content) => {
- *     c.res.headers.set("x-custom", "value");
- *     return content;
- * });
- */
-export declare class StaticRoute<Path extends string = string, B = unknown, S = unknown, P = unknown> extends RouteAbstract<Path, B, S, P, string | CResponse> {
-	constructor(path: Path, definition: StaticRouteDefinition, handler?: StaticRouteHandler<B, S, P>, model?: RouteModel<B, S, P, string | CResponse>);
-	id: RouteId;
+type R$1 = string | CResponse;
+export declare abstract class StaticRouteAbstract<Path extends string = string, B = unknown, S = unknown, P = unknown> extends RouteAbstract<Path, B, S, P, R$1> {
 	variant: RouteVariant;
-	method: Method;
+	protected abstract filePath: string;
+	protected resolveFilePath(definition: StaticRouteDefinition): string;
+	protected resolveHandler(definition: StaticRouteDefinition, customHandler?: StaticRouteHandler<B, S, P>): RouteHandler<B, S, P, R$1>;
+}
+type R$2 = string | CResponse;
+export declare class StaticRoute<Path extends string = string, B = unknown, S = unknown, P = unknown> extends StaticRouteAbstract<Path, B, S, P> {
+	constructor(path: Path, definition: StaticRouteDefinition, handler?: StaticRouteHandler<B, S, P>, model?: RouteModel<B, S, P, R$2>);
+	id: RouteId;
+	method: OrString<Method>;
 	endpoint: Path;
 	pattern: RegExp;
-	model?: RouteModel<B, S, P, string | CResponse> | undefined;
-	handler: RouteHandler<B, S, P, string | CResponse>;
-	private filePath;
-	private resolveFilePath;
-	private resolveHandler;
+	handler: RouteHandler<B, S, P, R$2>;
+	model?: RouteModel<B, S, P, R$2>;
+	protected filePath: string;
 }
 export type ControllerOptions = {
 	prefix?: string;
@@ -675,7 +692,7 @@ export type ControllerOptions = {
  * Base class for grouping related routes under a shared prefix and optional middleware.
  * Extend this class to create your own controllers.
  *
- * All routes registered via {@link ControllerAbstract.route} and {@link ControllerAbstract.staticRoute}
+ * All routes registered via {@link Controller.route} and {@link Controller.staticRoute}
  * automatically inherit the controller's prefix and run `beforeEach` before the handler if set.
  *
  * @example
@@ -693,16 +710,16 @@ export type ControllerOptions = {
  *
  * new UserController();
  */
-declare abstract class ControllerAbstract {
+export declare abstract class Controller {
 	constructor(opts?: ControllerOptions);
 	routeIds: Set<RouteId>;
 	protected prefix?: string;
 	protected beforeEach?: MiddlewareHandler;
 	/**
-	 * Registers a dynamic route under this controller. Behaves identically to {@link Route}
+	 * Registers a dynamic route under this controller. Behaves identically to {@link DynamicRoute}
 	 * but automatically prepends the controller prefix and runs `beforeEach` before the handler.
 	 */
-	protected route<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown>(...args: ConstructorParameters<typeof Route<Path, B, S, P, R>>): Route<Path, B, S, P, R>;
+	protected route<Path extends string = string, B = unknown, S = unknown, P = unknown, R = unknown>(...args: ConstructorParameters<typeof DynamicRoute<Path, B, S, P, R>>): DynamicRoute<Path, B, S, P, R>;
 	/**
 	 * Registers a static file route under this controller. Behaves identically to {@link StaticRoute}
 	 * but automatically prepends the controller prefix.
@@ -710,7 +727,11 @@ declare abstract class ControllerAbstract {
 	protected staticRoute<Path extends string = string, B = unknown, S = unknown, P = unknown>(...args: ConstructorParameters<typeof StaticRoute<Path, B, S, P>>): StaticRoute<Path, B, S, P>;
 	private resolveRouteDefinition;
 }
-export type MiddlewareUseOn = Array<AnyRoute | ControllerAbstract> | AnyRoute | ControllerAbstract | "*";
+export type MiddlewareUseOn = Array<AnyRoute | Controller> | AnyRoute | Controller | "*";
+export declare abstract class MiddlewareAbstract {
+	abstract useOn: MiddlewareUseOn;
+	abstract handler: MiddlewareHandler;
+}
 export type MiddlewareOptions = {
 	useOn: MiddlewareUseOn;
 	handler: MiddlewareHandler;
@@ -719,38 +740,96 @@ export type MiddlewareOptions = {
  * Simple middleware that runs before the Route "callback" parameters.
  * Manipulates context.
  * */
-export declare class Middleware {
+export declare class Middleware extends MiddlewareAbstract {
 	constructor(opts: MiddlewareOptions);
 	useOn: MiddlewareUseOn;
 	handler: MiddlewareHandler;
 }
-export type AnyRouteModel = RouteModel<any, any, any, any>;
-export type RouterRouteData = Pick<AnyRoute, "id" | "endpoint" | "method" | "pattern" | "handler">;
-export type RouterReturnData = {
-	route: RouterRouteData;
-	model: RouterModelData | undefined;
-	middleware: MiddlewareHandler | undefined;
-	params: Record<string, string>;
-	search: Record<string, string>;
-};
-export interface RouterAdapterInterface {
-	find(req: CRequest): RouterReturnData | null;
-	list(): Array<RouterRouteData>;
-	addRoute(data: RouterRouteData): void;
-	addModel(route: AnyRoute, model: AnyRouteModel): void;
-	addMiddleware(middleware: Middleware): void;
+export interface CWebSocketInterface {
+	/**
+	 * - if **0**, the message was **dropped**.
+	 * - if **-1**, there is **backpressure** of messages.
+	 * - if **>0**, it represents the **number of bytes sent**.
+	 */
+	send(data: string | ArrayBufferLike): number;
+	publish(topic: string, data: string | ArrayBufferLike): number;
+	cork(callback: (ws: CWebSocketInterface) => unknown): unknown;
+	/**
+	 * Closes the connection.
+	 * To close the connection abruptly, use `terminate()`.
+	 */
+	close(code?: number, reason?: string): void;
+	/**
+	 * Abruptly close the connection.
+	 * To gracefully close the connection, use `close()`.
+	 */
+	terminate(): void;
+	subscribe(topic: string): void;
+	unsubscribe(topic: string): void;
+	isSubscribed(topic: string): boolean;
+	readonly subscriptions: string[];
+	/** The IP address of the client. */
+	readonly remoteAddress: string;
+	/**
+	 * The ready state of the client.
+	 *
+	 * - if `0`, the client is connecting.
+	 * - if `1`, the client is connected.
+	 * - if `2`, the client is closing.
+	 * - if `3`, the client is closed.
+	 */
+	readonly readyState: 0 | 1 | 2 | 3;
+}
+export interface WebSocketHandlers {
+	onOpen?: Func<[
+		ws: CWebSocketInterface
+	], MaybePromise<void>>;
+	onClose?: Func<[
+		ws: CWebSocketInterface,
+		code?: number,
+		reason?: string
+	], MaybePromise<void>>;
+	onMessage: Func<[
+		ws: CWebSocketInterface,
+		message: string | Buffer
+	], MaybePromise<void>>;
+}
+export declare class WebSocketRoute<Path extends string = string, B = unknown, S = unknown, P = unknown> extends RouteAbstract<Path, B, S, P, WebSocketRoute> {
+	constructor(path: Path, handlers: WebSocketHandlers);
+	id: RouteId;
+	method: OrString<Method>;
+	endpoint: Path;
+	pattern: RegExp;
+	model?: RouteModel<B, S, P, WebSocketRoute>;
+	handler: RouteHandler<B, S, P, WebSocketRoute>;
+	variant: RouteVariant;
+	readonly onOpen?: Func<[
+		ws: CWebSocketInterface
+	], MaybePromise<void>>;
+	readonly onClose?: Func<[
+		ws: CWebSocketInterface,
+		code?: number,
+		reason?: string
+	], MaybePromise<void>>;
+	readonly onMessage: Func<[
+		ws: CWebSocketInterface,
+		message: string | Buffer
+	], MaybePromise<void>>;
 }
 declare class Router {
+	private adapter;
 	constructor(adapter?: RouterAdapterInterface);
-	models: AnyRouteModel[];
-	private _adapter;
+	private modelRegistry;
+	private middlewareRegistry;
 	private cache;
-	checkPossibleCollision(n: RouterRouteData): boolean;
-	addModel(route: AnyRoute, model: AnyRouteModel): void;
 	addMiddleware(middleware: Middleware): void;
-	addRoute(r: AnyRoute): void;
+	findMiddleware(id: RouteId | "*"): Func<[
+		Context
+	]>;
+	addRoute(route: AnyRoute): void;
 	findRouteHandler(req: CRequest): Func<[
-	], Promise<CResponse>>;
+		Context
+	], Promise<CResponse | WebSocketRoute>> | null;
 	getRouteList(): Array<[
 		string,
 		string
@@ -761,24 +840,35 @@ declare class GlobalRouterStore extends StoreAbstract<Router | null> {
 	get(): Router;
 }
 export type CorsOptions = {
+	/** Which origins are allowed to access the resource */
 	allowedOrigins?: string[];
+	/** Which HTTP methods are allowed (GET, POST, etc.) */
 	allowedMethods?: string[];
+	/** Which headers can be sent in the request */
 	allowedHeaders?: HeaderKey[];
+	/** Which headers should be exposed to the client/browser JavaScript
+	 * These are response headers that the client can read
+	 * @example ['RateLimit-Limit', 'RateLimit-Remaining', 'X-Custom-Header']
+	 */
+	exposedHeaders?: HeaderKey[];
+	/** Whether to expose cookies and auth headers to the client */
 	credentials?: boolean;
 };
 /** Simple cors helper object to set cors headers */
-export declare class Cors {
-	readonly opts: CorsOptions | undefined;
+declare class XCors {
+	opts: CorsOptions | undefined;
 	constructor(opts: CorsOptions | undefined);
 	private readonly originKey;
 	private readonly methodsKey;
 	private readonly headersKey;
 	private readonly credentialsKey;
-	getCorsHeaders(req: CRequest, res: CResponse): CHeaders;
+	private readonly exposedHeadersKey;
+	private getCorsHeaders;
 	apply(req: CRequest, res: CResponse): void;
+	updateOptions(newOpts: CorsOptions): void;
 }
-declare class GlobalCorsStore extends StoreAbstract<Cors | null> {
-	protected value: Cors | null;
+declare class GlobalCorsStore extends StoreAbstract<XCors | null> {
+	protected value: XCors | null;
 }
 export type ConfigEnvKey = OrString<keyof Env>;
 export type ConfigValueParser<T> = Func<[
@@ -803,11 +893,6 @@ declare class CError extends Error {
 	constructor(message: string, status: Status, data?: unknown | undefined);
 	toResponse(): CResponse;
 	isStatusOf(status: Status): boolean;
-	static internalServerError(msg?: string): CError;
-	static badRequest(msg?: string): CError;
-	static notFound(msg?: string): CError;
-	static methodNotAllowed(msg?: string): CError;
-	static unprocessableEntity(msg?: string): CError;
 }
 export type InferSchema<T extends Schema> = StandardSchemaV1.InferOutput<T>;
 export type ServerTlsOptions = {
@@ -823,7 +908,6 @@ export type ServerOptions = {
 export type ServeArgs = {
 	port: number;
 	hostname?: "0.0.0.0" | "127.0.0.1" | "localhost" | (string & {}) | undefined;
-	fetch: (request: Request) => Promise<Response>;
 };
 export type ErrorHandler<R = unknown> = Func<[
 	Error
@@ -837,7 +921,13 @@ export type AfterResponseHandler = Func<[
 export interface ServerInterface {
 	serve(options: ServeArgs): void;
 	close(): Promise<void>;
+	get routes(): Array<[
+		string,
+		string
+	]>;
 	setGlobalPrefix(value: string): void;
+	listen(port: ServeArgs["port"], hostname?: ServeArgs["hostname"]): Promise<void>;
+	handle(request: Request): Promise<Response>;
 	/**
 	 *
 	 * Default error handler response will have a status of C.Error or 500 and json:
@@ -854,6 +944,7 @@ export interface ServerInterface {
 	 * ```
 	 */
 	setOnError(handler: ErrorHandler): void;
+	defaultErrorHandler: ErrorHandler;
 	/**
 	 *
 	 * Default not found handler response will have a status of 404 and json:
@@ -863,11 +954,18 @@ export interface ServerInterface {
 	 * ```
 	 */
 	setOnNotFound(handler: RequestHandler): void;
-	setOnBeforeListen(handler: () => MaybePromise<void>): void;
+	defaultNotFoundHandler: RequestHandler;
+	setOnBeforeListen(handler: Func<[
+	], MaybePromise<void>> | undefined): void;
+	defaultOnBeforeListen: Func<[
+	], MaybePromise<void>> | undefined;
 	setOnBeforeClose(handler: () => MaybePromise<void>): void;
-	setOnAfterResponse(handler: AfterResponseHandler): void;
-	listen(port: ServeArgs["port"], hostname: ServeArgs["hostname"]): Promise<void>;
-	handle(request: Request): Promise<Response>;
+	defaultOnBeforeClose: Func<[
+	], MaybePromise<void>> | undefined;
+	setOnAfterResponse(handler: AfterResponseHandler | undefined): void;
+	defaultOnAfterResponse: AfterResponseHandler | undefined;
+	setOnPreflight(handler: RequestHandler): void;
+	defaultPreflightHandler: RequestHandler;
 }
 declare abstract class ServerAbstract implements ServerInterface {
 	protected readonly opts?: ServerOptions | undefined;
@@ -881,7 +979,9 @@ declare abstract class ServerAbstract implements ServerInterface {
 	setGlobalPrefix(value: string): void;
 	listen(port: ServeArgs["port"], hostname?: ServeArgs["hostname"]): Promise<void>;
 	handle(request: Request): Promise<Response>;
-	private getResponse;
+	protected handleRequest(req: CRequest, onUpgrade: Func<[
+		WebSocketRoute
+	], undefined>): Promise<Response | undefined>;
 	protected handleBeforeListen: Func<[
 	], MaybePromise<void>> | undefined;
 	setOnBeforeListen(handler: Func<[
@@ -902,20 +1002,12 @@ declare abstract class ServerAbstract implements ServerInterface {
 	protected handleNotFound: RequestHandler;
 	setOnNotFound(handler: RequestHandler): void;
 	defaultNotFoundHandler: RequestHandler;
-	protected handleMethodNotAllowed: RequestHandler;
-	defaultMethodNotFoundHandler: RequestHandler;
+	protected handlePreflight: RequestHandler;
+	setOnPreflight(handler: RequestHandler): void;
+	defaultPreflightHandler: RequestHandler;
 }
-declare class ServerUsingBun extends ServerAbstract {
-	private app;
-	serve(args: ServeArgs): void;
-	close(): Promise<void>;
-	private createApp;
-}
-/**
- * Server is the entrypoint to the app. It must be initialized before registering routes and middlewares.
- * ".listen()" to start listening.
- */
-export declare class Server extends ServerUsingBun {
+declare const Adapted$1: ConstructorOf<typeof ServerAbstract, ServerInterface>;
+export declare class Server extends Adapted$1 {
 }
 export interface XFileInterface {
 	get name(): string;
@@ -936,32 +1028,169 @@ declare abstract class XFileAbstract implements XFileInterface {
 	get extension(): string;
 	get mimeType(): string;
 }
-declare class XFileUsingBun extends XFileAbstract implements XFileInterface {
-	constructor(...args: ConstructorParameters<typeof XFileAbstract>);
-	file: Bun.BunFile;
-	exists(): Promise<boolean>;
-	text(): Promise<string>;
-	stream(): ReadableStream;
-}
-declare class XFile extends XFileUsingBun {
+declare const Adapted$2: ConstructorOf<typeof XFileAbstract, XFileInterface>;
+declare class XFile extends Adapted$2 {
 }
 /** Abstract class for repository implementations */
-declare abstract class RepositoryAbstract {
+declare abstract class XRepository {
 	readonly db: DatabaseClientInterface;
 	constructor(db: DatabaseClientInterface);
 }
 /** Router Adapter for the "memoirist" package. */
 export declare class MemoiristAdapter implements RouterAdapterInterface {
 	private router;
-	private pendingMiddlewares;
 	find(req: CRequest): RouterReturnData | null;
 	list(): Array<RouterRouteData>;
-	addRoute(data: RouterRouteData): void;
-	addModel(route: AnyRoute, model: AnyRouteModel): void;
-	addMiddleware(middleware: Middleware): void;
+	add(data: RouterRouteData): void;
+}
+export interface BasicRedisClientInterface {
+	get: Func<[
+		string
+	], Promise<string>>;
+	set: Func<[
+		string,
+		string,
+		string,
+		number
+	], Promise<void>>;
+	del: Func<string[], Promise<void>>;
+	keys: Func<[
+		string
+	], Promise<string[]>>;
+}
+export type RateLimitIdPrefix = "u" | "i" | "f";
+export type RateLimitConfig<R extends BasicRedisClientInterface | undefined = undefined> = {
+	/**
+	 * Limits based on identifier type:
+	 * u: Authenticated users — higher limit, accountable identity (e.g., 120 requests)
+	 * i: IP-based — moderate, may be shared (NAT, proxies) (e.g., 60 requests)
+	 * f: Fingerprint / anonymous — lowest, least trustworthy (e.g., 20 requests)
+	 * */
+	limits: Record<RateLimitIdPrefix, number>;
+	/** Time window in milliseconds during which the rate limit applies (default: 60,000ms = 1 minute) */
+	windowMs: number;
+	/** How often to rotate the salt used for hashing identifiers (default: 24h)
+	 * Prevents long-term tracking and adds an extra layer of privacy */
+	saltRotateMs: number;
+	/** Probability (0-1) of triggering a cleanup of expired entries on each request
+	 * Balances memory usage against performance (default: 0.005 = 0.5%) */
+	cleanProbability: number;
+	/** Maximum number of entries before forcing a cleanup
+	 * Prevents unbounded memory growth (default: 50,000) */
+	maxStoreSize: number;
+	/** Storage backend type:
+	 * - memory: Fastest, but resets on server restart (default)
+	 * - file: Persistent across restarts, good for single instance
+	 * - redis: Distributed, for multi-instance deployments
+	 * */
+	storeType: "memory" | "file" | "redis";
+	/** Redis client instance (required when storeType = "redis") */
+	redisClient?: R;
+	/** Directory path for file-based storage (required when storeType = "file") */
+	storeDir?: string;
+	/**
+	 * Customizable HTTP header names for rate limit information.
+	 * Allows integration with different API conventions or frontend expectations.
+	 *
+	 * @example
+	 * // Custom header names (e.g., for legacy systems)
+	 * headerNames: {
+	 *   limit: "X-RateLimit-Limit",
+	 *   remaining: "X-RateLimit-Remaining",
+	 *   reset: "X-RateLimit-Reset",
+	 *   retryAfter: "Retry-After"
+	 * }
+	 *
+	 * @default Uses standard RateLimit-* headers as defined in IETF draft:
+	 * - limit: "RateLimit-Limit"
+	 * - remaining: "RateLimit-Remaining"
+	 * - reset: "RateLimit-Reset"
+	 * - retryAfter: "Retry-After"
+	 */
+	headerNames: {
+		/** Header name for the maximum allowed requests in the current window */
+		limit: string;
+		/** Header name for the remaining requests in the current window */
+		remaining: string;
+		/** Header name for the timestamp (Unix seconds) when the window resets */
+		reset: string;
+		/** Header name for seconds to wait before retrying when rate limited */
+		retryAfter: string;
+	};
+};
+declare class XRateLimiter {
+	constructor(config?: Partial<RateLimitConfig>);
+	private readonly config;
+	private store;
+	private storedSalt;
+	private saltRotatesAt;
+	getResult(headers: CHeaders): Promise<{
+		success: boolean;
+		headers: CHeaders;
+	}>;
+	private getId;
+	private getMax;
+	private extractIp;
+	private isValidIp;
+	private salt;
+	private maybeCleanStore;
+	private cleanStore;
+	private hash;
+	private getRandomBytes;
+	clearStore(): Promise<void>;
+	getStoreSize(): Promise<number>;
+	private readonly defaultConfig;
+	private resolveStore;
+	private registerMiddleware;
+}
+export interface RateLimitEntry {
+	hits: number;
+	resetAt: number;
+}
+export interface RateLimitStoreInterface {
+	get(id: string): Promise<RateLimitEntry | undefined>;
+	set(id: string, entry: RateLimitEntry): Promise<void>;
+	delete(id: string): Promise<void>;
+	cleanup(now: number): Promise<void>;
+	clear(): Promise<void>;
+	size(): Promise<number>;
+}
+export declare class RateLimiterFileStore implements RateLimitStoreInterface {
+	private readonly storeDir;
+	private locks;
+	constructor(storeDir?: string);
+	private ensureStoreDir;
+	private getFilePath;
+	get(id: string): Promise<RateLimitEntry | undefined>;
+	set(id: string, entry: RateLimitEntry): Promise<void>;
+	delete(id: string): Promise<void>;
+	cleanup(now: number): Promise<void>;
+	clear(): Promise<void>;
+	size(): Promise<number>;
+}
+export declare class RateLimiterMemoryStore implements RateLimitStoreInterface {
+	private store;
+	private locks;
+	get(id: string): Promise<RateLimitEntry | undefined>;
+	set(id: string, entry: RateLimitEntry): Promise<void>;
+	delete(id: string): Promise<void>;
+	cleanup(now: number): Promise<void>;
+	clear(): Promise<void>;
+	size(): Promise<number>;
+}
+export declare class RateLimiterRedisStore<R extends BasicRedisClientInterface> implements RateLimitStoreInterface {
+	private readonly redis;
+	private readonly prefix;
+	constructor(redis: R, prefix?: string);
+	get(id: string): Promise<RateLimitEntry | undefined>;
+	set(id: string, entry: RateLimitEntry): Promise<void>;
+	delete(id: string): Promise<void>;
+	cleanup(_now: number): Promise<void>;
+	clear(): Promise<void>;
+	size(): Promise<number>;
 }
 export type UnknownObject = Record<string, unknown>;
-export declare class Parser {
+declare class XParser {
 	static parse<T = UnknownObject>(data: unknown, validate?: SchemaValidator<T>): Promise<T>;
 	static issuesToErrorMessage(issues: readonly StandardSchemaV1.Issue[]): string;
 	static parseUrlData<P = UnknownObject>(params: Record<string, string>, validate?: SchemaValidator<P>): Promise<P>;
@@ -978,7 +1207,7 @@ export type Prettify<T> = {
 	[K in keyof T]: T[K];
 } & {};
 /** If you prefer to put all schemas into a single object, this will be helpful */
-export type InferModel<T extends Record<string, any>> = {
+type XInferModel<T extends Record<string, any>> = {
 	[K in keyof T]: T[K] extends RouteModel<any, any, any, any> ? Prettify<(T[K]["body"] extends Schema ? {
 		body: InferSchema<T[K]["body"]>;
 	} : {}) & (T[K]["search"] extends Schema ? {
@@ -989,21 +1218,21 @@ export type InferModel<T extends Record<string, any>> = {
 		response: InferSchema<T[K]["response"]>;
 	} : {})> : T[K] extends Schema ? InferSchema<T[K]> : never;
 };
-export declare const _prefixStore: GlobalPrefixStore;
-export declare const _routerStore: GlobalRouterStore;
-export declare const _corsStore: GlobalCorsStore;
+export declare const $prefixStore: GlobalPrefixStore;
+export declare const $routerStore: GlobalRouterStore;
+export declare const $corsStore: GlobalCorsStore;
 
 declare namespace X {
-	export { Cors, CorsOptions, InferModel, MemoiristAdapter, Parser, RepositoryAbstract as Repository, XFile as File };
+	export { CorsOptions, MemoiristAdapter, RateLimiterFileStore, RateLimiterMemoryStore, RateLimiterRedisStore, RouterAdapterInterface, XCors as Cors, XFile as File, XInferModel as InferModel, XParser as Parser, XRateLimiter as RateLimiter, XRepository as Repository };
 }
 declare namespace C {
-	export { CError as Error, CHeaders as Headers, CHeadersInit as HeadersInit, CRequest as Request, CRequestInfo as RequestInfo, CRequestInit as RequestInit, CResponse as Response, CResponseBody as ResponseBody, CResponseInit as ResponseInit, CommonHeaders, Config, Context, ControllerAbstract as Controller, ControllerOptions, CookieOptions, Cookies, CookiesInit, HeaderKey, InferSchema, Method, Middleware, MiddlewareHandler, MiddlewareOptions, MiddlewareUseOn, Route, RouteDefinition, RouteHandler, Schema, SchemaValidator, ServeArgs, Server, ServerOptions, ServerTlsOptions, StaticRoute, StaticRouteHandler, Status };
+	export { CError as Error, CHeaders as Headers, CHeadersInit as HeadersInit, CRequest as Request, CRequestInfo as RequestInfo, CRequestInit as RequestInit, CResponse as Response, CResponseBody as ResponseBody, CResponseInit as ResponseInit, CommonHeaders, Config, Context, Controller, ControllerOptions, CookieOptions, Cookies, CookiesInit, DynamicRoute as Route, DynamicRouteAbstract, DynamicRouteDefinition, HeaderKey, InferSchema, Method, Middleware, MiddlewareAbstract, MiddlewareHandler, MiddlewareOptions, MiddlewareUseOn, RouteHandler, RouteInterface, Schema, SchemaValidator, ServeArgs, Server, ServerOptions, StaticRoute, StaticRouteAbstract, StaticRouteDefinition, StaticRouteHandler, Status, WebSocketRoute };
 }
 declare namespace _default {
-	export { CError as Error, CHeaders as Headers, CHeadersInit as HeadersInit, CRequest as Request, CRequestInfo as RequestInfo, CRequestInit as RequestInit, CResponse as Response, CResponseBody as ResponseBody, CResponseInit as ResponseInit, CommonHeaders, Config, Context, ControllerAbstract as Controller, ControllerOptions, CookieOptions, Cookies, CookiesInit, HeaderKey, InferSchema, Method, Middleware, MiddlewareHandler, MiddlewareOptions, MiddlewareUseOn, Route, RouteDefinition, RouteHandler, Schema, SchemaValidator, ServeArgs, Server, ServerOptions, ServerTlsOptions, StaticRoute, StaticRouteHandler, Status };
+	export { CError as Error, CHeaders as Headers, CHeadersInit as HeadersInit, CRequest as Request, CRequestInfo as RequestInfo, CRequestInit as RequestInit, CResponse as Response, CResponseBody as ResponseBody, CResponseInit as ResponseInit, CommonHeaders, Config, Context, Controller, ControllerOptions, CookieOptions, Cookies, CookiesInit, DynamicRoute as Route, DynamicRouteAbstract, DynamicRouteDefinition, HeaderKey, InferSchema, Method, Middleware, MiddlewareAbstract, MiddlewareHandler, MiddlewareOptions, MiddlewareUseOn, RouteHandler, RouteInterface, Schema, SchemaValidator, ServeArgs, Server, ServerOptions, StaticRoute, StaticRouteAbstract, StaticRouteDefinition, StaticRouteHandler, Status, WebSocketRoute };
 }
 declare namespace Extra {
-	export { Cors, CorsOptions, InferModel, MemoiristAdapter, Parser, RepositoryAbstract as Repository, XFile as File };
+	export { CorsOptions, MemoiristAdapter, RateLimiterFileStore, RateLimiterMemoryStore, RateLimiterRedisStore, RouterAdapterInterface, XCors as Cors, XFile as File, XInferModel as InferModel, XParser as Parser, XRateLimiter as RateLimiter, XRepository as Repository };
 }
 
 export {
@@ -1018,11 +1247,15 @@ export {
 	CResponse as Response,
 	CResponseBody as ResponseBody,
 	CResponseInit as ResponseInit,
-	ControllerAbstract as Controller,
+	DynamicRoute as Route,
 	Extra,
-	RepositoryAbstract as Repository,
 	X,
+	XCors as Cors,
 	XFile as File,
+	XInferModel as InferModel,
+	XParser as Parser,
+	XRateLimiter as RateLimiter,
+	XRepository as Repository,
 };
 
 export {};