@draftlab/auth 0.13.1 → 0.15.0

package/dist/core.d.mts

@@ -2,11 +2,11 @@ import { AllowCheckInput } from "./allow.mjs";
 import { UnknownStateError } from "./error.mjs";
 import { Prettify } from "./util.mjs";
 import { SubjectPayload, SubjectSchema } from "./subject.mjs";
+import { Router } from "./router/index.mjs";
 import { StorageAdapter } from "./storage/storage.mjs";
 import { Provider } from "./provider/provider.mjs";
 import { Theme } from "./themes/theme.mjs";
 import { AuthorizationState } from "./types.mjs";
-import { Router } from "@draftlab/auth-router";
 
 //#region src/core.d.ts
 

package/dist/core.mjs

@@ -6,12 +6,12 @@ import { generateSecureToken } from "./random.mjs";
 import { Storage } from "./storage/storage.mjs";
 import { encryptionKeys, signingKeys } from "./keys.mjs";
 import { Revocation } from "./revocation.mjs";
+import { Router } from "./router/index.mjs";
+import { deleteCookie, getCookie, setCookie } from "./router/cookies.mjs";
+import { cors } from "./router/middleware/cors.mjs";
 import { setTheme } from "./themes/theme.mjs";
 import { Select } from "./ui/select.mjs";
 import { CompactEncrypt, SignJWT, compactDecrypt } from "jose";
-import { Router } from "@draftlab/auth-router";
-import { deleteCookie, getCookie, setCookie } from "@draftlab/auth-router/cookies";
-import { cors } from "@draftlab/auth-router/middleware/cors";
 
 //#region src/core.ts
 /**

package/dist/provider/code.mjs

@@ -2,6 +2,89 @@ import { generateUnbiasedDigits, timingSafeCompare } from "../random.mjs";
 
 //#region src/provider/code.ts
 /**
+* PIN code authentication provider for Draft Auth.
+* Supports flexible claim-based authentication via email, phone, or custom identifiers.
+*
+* ## Quick Setup
+*
+* ```ts
+* import { CodeUI } from "@draftlab/auth/ui/code"
+* import { CodeProvider } from "@draftlab/auth/provider/code"
+*
+* export default issuer({
+*   providers: {
+*     code: CodeProvider(
+*       CodeUI({
+*         copy: {
+*           code_info: "We'll send a PIN code to your email"
+*         },
+*         sendCode: async (claims, code) => {
+*           try {
+*             await sendEmail(claims.email, `Your code: ${code}`)
+*           } catch {
+*             return { type: "invalid_claim", key: "delivery", value: "Failed to send code" }
+*           }
+*         }
+*       })
+*     )
+*   }
+* })
+* ```
+*
+* ## Custom Configuration
+*
+* ```ts
+* const customCodeProvider = CodeProvider({
+*   length: 4, // 4-digit PIN instead of default 6
+*   request: async (req, state, form, error) => {
+*     return new Response(renderCodePage(state, form, error))
+*   },
+*   sendCode: async (claims, code) => {
+*     try {
+*       if (claims.email) {
+*         await emailService.send(claims.email, code)
+*       } else if (claims.phone) {
+*         await smsService.send(claims.phone, code)
+*       } else {
+*         return { type: "invalid_claim", key: "email", value: "Email or phone number is required" }
+*       }
+*     } catch {
+*       return { type: "invalid_claim", key: "delivery", value: "Failed to send code" }
+*     }
+*   }
+* })
+* ```
+*
+* ## Features
+*
+* - **Flexible claims**: Support any claim type (email, phone, username, etc.)
+* - **Configurable PIN length**: 4-6 digit codes typically
+* - **Resend functionality**: Built-in code resend capability
+* - **Custom UI**: Full control over the authentication interface
+* - **Error handling**: Comprehensive error states for different failure modes
+*
+* ## Flow States
+*
+* The provider manages a two-step authentication flow:
+*
+* 1. **Start**: User enters their claim (email, phone, etc.)
+* 2. **Code**: User enters the PIN code sent to their claim
+*
+* ## User Data
+*
+* ```ts
+* success: async (ctx, value) => {
+*   if (value.provider === "code") {
+*     // User's email: value.claims.email
+*     // User's phone (if provided): value.claims.phone
+*     // Any other claims collected during the flow
+*   }
+* }
+* ```
+*
+* @packageDocumentation
+*/
+/**
 * Creates a PIN code authentication provider.
 * Implements a flexible claim-based authentication flow with PIN verification.
 *
@@ -145,6 +228,11 @@ const CodeProvider = (config) => {
 						...currentState,
 						resend: false
 					}, formData, { type: "invalid_code" });
+					if (!await ctx.get(c, "authorization")) return transition(c, { type: "start" }, formData, {
+						type: "invalid_claim",
+						key: "session",
+						value: "Authentication session expired"
+					});
 					await ctx.unset(c, "provider");
 					return await ctx.success(c, { claims: currentState.claims });
 				}

package/dist/provider/magiclink.mjs

@@ -2,6 +2,63 @@ import { generateUnbiasedDigits, timingSafeCompare } from "../random.mjs";
 
 //#region src/provider/magiclink.ts
 /**
+* Magic Link authentication provider for Draft Auth.
+* Sends clickable links that authenticate users in one click.
+*
+* ## Quick Setup
+*
+* ```ts
+* import { MagicLinkUI } from "@draftlab/auth/ui/magiclink"
+* import { MagicLinkProvider } from "@draftlab/auth/provider/magiclink"
+*
+* export default issuer({
+*   providers: {
+*     magiclink: MagicLinkProvider(
+*       MagicLinkUI({
+*         sendLink: async (claims, magicUrl) => {
+*           await emailService.send({
+*             to: claims.email,
+*             subject: "Sign in to your account",
+*             html: `<a href="${magicUrl}">Sign In</a>`
+*           })
+*         }
+*       })
+*     )
+*   }
+* })
+* ```
+*
+* ## Custom Configuration
+*
+* ```ts
+* const customMagicLink = MagicLinkProvider({
+*   expiry: 600, // 10 minutes instead of default 15
+*
+*   request: async (req, state, form, error) => {
+*     return new Response(renderMagicLinkForm(state, form, error))
+*   },
+*
+*   sendLink: async (claims, magicUrl) => {
+*     try {
+*       if (claims.email) {
+*         await emailService.send(claims.email, {
+*           subject: "Your secure sign-in link",
+*           template: "magic-link",
+*           data: { magicUrl, userEmail: claims.email }
+*         })
+*       } else {
+*         return { type: "invalid_claim", key: "email", value: "Email is required" }
+*       }
+*     } catch {
+*       return { type: "invalid_claim", key: "delivery", value: "Failed to send magic link" }
+*     }
+*   }
+* })
+* ```
+*
+* @packageDocumentation
+*/
+/**
 * Creates a Magic Link authentication provider.
 * Implements a flexible claim-based authentication flow with magic link verification.
 *
@@ -74,6 +131,7 @@ const MagicLinkProvider = (config) => {
 					if (!urlValue || !storedValue) return false;
 					return timingSafeCompare(storedValue, urlValue);
 				})) return transition(c, { type: "start" }, void 0, { type: "invalid_link" });
+				if (!await ctx.get(c, "authorization")) return transition(c, { type: "start" }, void 0, { type: "invalid_link" });
 				await ctx.unset(c, "provider");
 				return await ctx.success(c, { claims: storedState.claims });
 			});

package/dist/provider/oauth2.mjs

@@ -6,6 +6,63 @@ import { createRemoteJWKSet, jwtVerify } from "jose";
 
 //#region src/provider/oauth2.ts
 /**
+* OAuth 2.0 authentication provider for Draft Auth.
+* Implements the Authorization Code Grant flow with optional PKCE support.
+*
+* ## Quick Setup
+*
+* ```ts
+* import { Oauth2Provider } from "@draftlab/auth/provider/oauth2"
+*
+* export default issuer({
+*   providers: {
+*     github: Oauth2Provider({
+*       clientID: process.env.GITHUB_CLIENT_ID,
+*       clientSecret: process.env.GITHUB_CLIENT_SECRET,
+*       endpoint: {
+*         authorization: "https://github.com/login/oauth/authorize",
+*         token: "https://github.com/login/oauth/access_token"
+*       },
+*       scopes: ["user:email", "read:user"]
+*     }),
+*     discord: Oauth2Provider({
+*       clientID: process.env.DISCORD_CLIENT_ID,
+*       clientSecret: process.env.DISCORD_CLIENT_SECRET,
+*       endpoint: {
+*         authorization: "https://discord.com/api/oauth2/authorize",
+*         token: "https://discord.com/api/oauth2/token"
+*       },
+*       scopes: ["identify", "email"],
+*       pkce: true // Required by some providers
+*     })
+*   }
+* })
+* ```
+*
+* ## Features
+*
+* - **Authorization Code Grant**: Secure server-side OAuth 2.0 flow
+* - **PKCE Support**: Optional Proof Key for Code Exchange for enhanced security
+* - **Flexible Endpoints**: Configure custom authorization and token endpoints
+* - **Custom Parameters**: Support for provider-specific authorization parameters
+*
+* ## User Data
+*
+* The provider returns access tokens:
+*
+* ```ts
+* success: async (ctx, value) => {
+*   if (value.provider === "oauth2") {
+*     // Access token for API calls: value.tokenset.access
+*     // Refresh token (if provided): value.tokenset.refresh
+*     // Client ID used: value.clientID
+*   }
+* }
+* ```
+*
+* @packageDocumentation
+*/
+/**
 * Creates an OAuth 2.0 authentication provider.
 * Implements the Authorization Code Grant flow with optional PKCE support.
 *

package/dist/provider/passkey.mjs

@@ -171,7 +171,7 @@ const PasskeyProvider = (config) => {
 					authenticatorSelection: authenticatorSelection ?? {
 						residentKey: "preferred",
 						userVerification: "preferred",
-						authenticatorAttachment: otherDevice ? "cross-platform" : "platform"
+						authenticatorAttachment: otherDevice ? void 0 : "platform"
 					},
 					timeout
 				});

package/dist/provider/password.mjs

@@ -193,6 +193,14 @@ const PasswordProvider = (config) => {
 						type: "start",
 						redirect: provider.redirect
 					}, { type: "invalid_email" });
+					if (!await Storage.get(ctx.storage, [
+						"email",
+						email,
+						"password"
+					])) return transition({
+						type: "start",
+						redirect: provider.redirect
+					}, { type: "invalid_email" });
 					const code = generateCode();
 					const context = provider.type === "code" && provider.email === email ? "reset:resend" : "reset";
 					await config.sendCode(email, code, context);
@@ -221,6 +229,7 @@ const PasswordProvider = (config) => {
 					const password = formData.get("password")?.toString();
 					const repeat = formData.get("repeat")?.toString();
 					if (!password) return transition(provider, { type: "invalid_password" });
+					if (!repeat) return transition(provider, { type: "invalid_password" });
 					if (password !== repeat) return transition(provider, { type: "password_mismatch" });
 					if (config.validatePassword) {
 						let validationError;

package/dist/provider/provider.d.mts

@@ -1,6 +1,6 @@
+import { RouterContext } from "../router/types.mjs";
+import { Router } from "../router/index.mjs";
 import { StorageAdapter } from "../storage/storage.mjs";
-import { Router } from "@draftlab/auth-router";
-import { RouterContext } from "@draftlab/auth-router/types";
 
 //#region src/provider/provider.d.ts
 

package/dist/router/context.d.mts

@@ -0,0 +1,21 @@
+import { RouterContext, VariableMap } from "./types.mjs";
+
+//#region src/router/context.d.ts
+declare class ContextBuilder<TVariables extends VariableMap = VariableMap> {
+  private readonly request;
+  private readonly matchedParams;
+  private readonly searchParams;
+  private readonly cookies;
+  private readonly variableManager;
+  private readonly responseHeaders;
+  private status;
+  private finalized;
+  private cachedFormData;
+  private formDataPromise;
+  private bodyText;
+  constructor(request: Request, matchedParams: Record<string, string>, initialVariables?: Partial<TVariables>);
+  build<TParams extends Record<string, string>>(): RouterContext<TParams, TVariables>;
+  newResponse(body?: BodyInit, init?: ResponseInit): Response;
+}
+//#endregion
+export { ContextBuilder };

package/dist/router/context.mjs

@@ -0,0 +1,193 @@
+import { ContextVariableManager } from "./variables.mjs";
+
+//#region src/router/context.ts
+const parseCookies = (request) => {
+	const cookies = /* @__PURE__ */ new Map();
+	const cookieHeader = request.headers.get("cookie");
+	if (!cookieHeader) return cookies;
+	try {
+		for (const cookie of cookieHeader.split(";")) {
+			const trimmedCookie = cookie.trim();
+			if (!trimmedCookie) continue;
+			const [name, ...valueParts] = trimmedCookie.split("=");
+			if (!name || name.trim() === "") continue;
+			const trimmedName = name.trim();
+			if (!/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/.test(trimmedName)) {
+				console.warn(`Invalid cookie name: ${trimmedName}`);
+				continue;
+			}
+			const value = valueParts.join("=");
+			try {
+				cookies.set(trimmedName, decodeURIComponent(value));
+			} catch {
+				cookies.set(trimmedName, value);
+			}
+		}
+	} catch (error) {
+		console.error("Failed to parse cookies:", error);
+	}
+	return cookies;
+};
+const serializeCookie = (name, value, options = {}) => {
+	if (!/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/.test(name)) throw new Error(`Invalid cookie name: ${name}`);
+	const parts = [`${name}=${encodeURIComponent(value)}`];
+	if (options.domain) parts.push(`Domain=${options.domain}`);
+	if (options.path) parts.push(`Path=${options.path}`);
+	if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+	if (options.maxAge) parts.push(`Max-Age=${options.maxAge}`);
+	if (options.httpOnly) parts.push("HttpOnly");
+	if (options.secure) parts.push("Secure");
+	if (options.sameSite) parts.push(`SameSite=${options.sameSite}`);
+	return parts.join("; ");
+};
+const validateRedirectStatus = (status) => {
+	if (![
+		300,
+		301,
+		302,
+		303,
+		307,
+		308
+	].includes(status)) throw new Error(`Invalid redirect status code: ${status}.`);
+	return true;
+};
+var ContextBuilder = class {
+	request;
+	matchedParams;
+	searchParams;
+	cookies;
+	variableManager;
+	responseHeaders = new Headers();
+	status = 200;
+	finalized = false;
+	cachedFormData = null;
+	formDataPromise = null;
+	bodyText = null;
+	constructor(request, matchedParams, initialVariables) {
+		if (!request || typeof request !== "object" || !request.url || !request.method) throw new Error("Invalid request object provided to ContextBuilder.");
+		this.request = request;
+		this.matchedParams = matchedParams;
+		this.searchParams = new URL(request.url).searchParams;
+		this.cookies = parseCookies(request);
+		this.variableManager = new ContextVariableManager(initialVariables);
+		Object.freeze(this.matchedParams);
+	}
+	build() {
+		return {
+			request: this.request,
+			params: this.matchedParams,
+			searchParams: this.searchParams,
+			query: (key) => this.searchParams.get(key) ?? void 0,
+			header: (key) => this.request.headers.get(key) ?? void 0,
+			cookie: (key) => this.cookies.get(key),
+			formData: async () => {
+				if (this.cachedFormData) return this.cachedFormData;
+				if (this.formDataPromise) try {
+					return await this.formDataPromise;
+				} catch {
+					this.formDataPromise = null;
+				}
+				this.formDataPromise = (async () => {
+					try {
+						const formData = await this.request.formData();
+						this.cachedFormData = formData;
+						return formData;
+					} catch (error) {
+						this.formDataPromise = null;
+						throw new Error(`Failed to read form data: ${error instanceof Error ? error.message : "Unknown error"}`);
+					}
+				})();
+				return this.formDataPromise;
+			},
+			parseJson: async () => {
+				try {
+					if (this.bodyText !== null) {
+						if (!this.bodyText) throw new Error("Request body is empty.");
+						return JSON.parse(this.bodyText);
+					}
+					const text = await this.request.text();
+					this.bodyText = text;
+					if (!text) throw new Error("Request body is empty.");
+					return JSON.parse(text);
+				} catch (error) {
+					throw new Error(`Failed to parse JSON: ${error instanceof Error ? error.message : "Unknown error"}`);
+				}
+			},
+			redirect: (url, status = 302) => {
+				validateRedirectStatus(status);
+				const location = url instanceof URL ? url.toString() : url;
+				return this.newResponse(void 0, {
+					status,
+					headers: { location }
+				});
+			},
+			json: (data, init) => {
+				const finalInit = {
+					...init,
+					headers: {
+						"content-type": "application/json; charset=utf-8",
+						...init?.headers
+					}
+				};
+				return this.newResponse(JSON.stringify(data), finalInit);
+			},
+			text: (data, init) => {
+				const finalInit = {
+					...init,
+					headers: {
+						"content-type": "text/plain; charset=utf-8",
+						...init?.headers
+					}
+				};
+				return this.newResponse(data, finalInit);
+			},
+			setCookie: (name, value, options) => {
+				try {
+					const cookie = serializeCookie(name, value, options);
+					this.responseHeaders.append("Set-Cookie", cookie);
+				} catch (error) {
+					console.error(`Failed to set cookie "${name}":`, error);
+				}
+			},
+			deleteCookie: (name, options) => {
+				try {
+					const cookie = serializeCookie(name, "", {
+						...options,
+						expires: /* @__PURE__ */ new Date(0)
+					});
+					this.responseHeaders.append("Set-Cookie", cookie);
+				} catch (error) {
+					console.error(`Failed to delete cookie "${name}":`, error);
+				}
+			},
+			newResponse: (body, init) => this.newResponse(body, init),
+			set: (key, value) => {
+				this.variableManager.set(key, value);
+			},
+			get: (key) => {
+				return this.variableManager.get(key);
+			},
+			has: (key) => {
+				return this.variableManager.has(key);
+			}
+		};
+	}
+	newResponse(body, init) {
+		if (this.finalized) throw new Error("Response already finalized");
+		const finalHeaders = new Headers(this.responseHeaders);
+		if (init?.headers) new Headers(init.headers).forEach((value, key) => {
+			if (key.toLowerCase() === "set-cookie") finalHeaders.append(key, value);
+			else finalHeaders.set(key, value);
+		});
+		const response = new Response(body, {
+			status: init?.status || this.status,
+			statusText: init?.statusText,
+			headers: finalHeaders
+		});
+		this.finalized = true;
+		return response;
+	}
+};
+
+//#endregion
+export { ContextBuilder };

package/dist/router/cookies.d.mts

@@ -0,0 +1,8 @@
+import { CookieOptions, RouterContext, VariableMap } from "./types.mjs";
+
+//#region src/router/cookies.d.ts
+declare const getCookie: <TVariables extends VariableMap = VariableMap>(ctx: RouterContext<Record<string, string>, TVariables>, name: string) => string | undefined;
+declare const setCookie: <TVariables extends VariableMap = VariableMap>(ctx: RouterContext<Record<string, string>, TVariables>, name: string, value: string, options?: CookieOptions) => void;
+declare const deleteCookie: <TVariables extends VariableMap = VariableMap>(ctx: RouterContext<Record<string, string>, TVariables>, name: string, options?: Pick<CookieOptions, "domain" | "path">) => void;
+//#endregion
+export { deleteCookie, getCookie, setCookie };

package/dist/router/cookies.mjs

@@ -0,0 +1,13 @@
+//#region src/router/cookies.ts
+const getCookie = (ctx, name) => {
+	return ctx.cookie(name);
+};
+const setCookie = (ctx, name, value, options) => {
+	ctx.setCookie(name, value, options);
+};
+const deleteCookie = (ctx, name, options) => {
+	ctx.deleteCookie(name, options);
+};
+
+//#endregion
+export { deleteCookie, getCookie, setCookie };

package/dist/router/index.d.mts

@@ -0,0 +1,21 @@
+import { AnyHandler, ErrorHandler, ExtractParams, GlobalMiddleware, RouterEnvironment, RouterOptions } from "./types.mjs";
+
+//#region src/router/index.d.ts
+declare class Router<TEnvironment extends RouterEnvironment = RouterEnvironment> {
+  private readonly routes;
+  private readonly matcher;
+  private readonly globalMiddleware;
+  private errorHandler?;
+  constructor(routerOptions?: RouterOptions);
+  private addRoute;
+  get<TPath extends string>(path: TPath, handler: AnyHandler<ExtractParams<TPath>, TEnvironment["Variables"]>): this;
+  post<TPath extends string>(path: TPath, handler: AnyHandler<ExtractParams<TPath>, TEnvironment["Variables"]>): this;
+  use(middleware: GlobalMiddleware<TEnvironment["Variables"]>): this;
+  onError(handler: ErrorHandler<TEnvironment["Variables"]>): this;
+  mount<TMountedEnvironment extends RouterEnvironment>(path: string, router: Router<TMountedEnvironment>): this;
+  handle(request: Request, initialVariables?: Partial<TEnvironment["Variables"]>): Promise<Response>;
+  get fetch(): (request: Request) => Promise<Response>;
+  private createErrorResponse;
+}
+//#endregion
+export { Router };

package/dist/router/index.mjs

@@ -0,0 +1,107 @@
+import { ContextBuilder } from "./context.mjs";
+import { RouteMatcher } from "./matcher.mjs";
+import { makeSafeRequest } from "./safe-request.mjs";
+
+//#region src/router/index.ts
+var Router = class {
+	routes = /* @__PURE__ */ new Map();
+	matcher;
+	globalMiddleware = [];
+	errorHandler;
+	constructor(routerOptions = {}) {
+		this.matcher = new RouteMatcher(routerOptions);
+	}
+	addRoute(method, path, handler) {
+		const { handler: mainHandler, middleware = [] } = typeof handler === "function" ? { handler } : handler;
+		if (typeof mainHandler !== "function") throw new Error(`Handler for ${method} ${path} must be a function.`);
+		const route = {
+			method,
+			pattern: path,
+			handler: mainHandler,
+			middleware: [...this.globalMiddleware, ...middleware],
+			compiled: this.matcher.compile(path)
+		};
+		const methodRoutes = this.routes.get(method) ?? [];
+		if (methodRoutes.some((r) => r.pattern === path)) console.warn(`Route already exists: ${method} ${path}. Overwriting.`);
+		const newRoutes = [...methodRoutes.filter((r) => r.pattern !== path), route];
+		const sortedPatterns = this.matcher.sortRoutesBySpecificity(newRoutes.map((r) => r.pattern));
+		newRoutes.sort((a, b) => sortedPatterns.indexOf(a.pattern) - sortedPatterns.indexOf(b.pattern));
+		this.routes.set(method, newRoutes);
+		return this;
+	}
+	get(path, handler) {
+		return this.addRoute("GET", path, handler);
+	}
+	post(path, handler) {
+		return this.addRoute("POST", path, handler);
+	}
+	use(middleware) {
+		this.globalMiddleware.push(middleware);
+		return this;
+	}
+	onError(handler) {
+		this.errorHandler = handler;
+		return this;
+	}
+	mount(path, router) {
+		const normalizedPath = path.endsWith("/") ? path.slice(0, -1) : path;
+		for (const [method, routes] of router.routes) for (const route of routes) this.addRoute(method, `${normalizedPath}${route.pattern}`, {
+			handler: route.handler,
+			middleware: route.middleware
+		});
+		return this;
+	}
+	async handle(request, initialVariables) {
+		const safeRequest = await makeSafeRequest(request);
+		try {
+			const url = new URL(safeRequest.url);
+			const method = safeRequest.method.toUpperCase();
+			const pathname = this.matcher.normalizePath(url.pathname);
+			const methodRoutes = this.routes.get(method);
+			if (!methodRoutes) return this.createErrorResponse("Not Found", 404);
+			for (const route of methodRoutes) {
+				const match = this.matcher.match(route.pattern, pathname);
+				if (match) {
+					const context = new ContextBuilder(safeRequest, match.params, initialVariables).build();
+					const allMiddleware = [...this.globalMiddleware, ...route.middleware];
+					const run = async (index, ctx) => {
+						if (index < allMiddleware.length) {
+							const middleware = allMiddleware[index];
+							if (middleware) return middleware(ctx, () => run(index + 1, ctx));
+						}
+						return route.handler(ctx);
+					};
+					return await run(0, context);
+				}
+			}
+			return this.createErrorResponse(`Route not found: ${method} ${pathname}`, 404);
+		} catch (error) {
+			console.error("Router handle error:", error);
+			if (this.errorHandler) try {
+				const errorContext = new ContextBuilder(safeRequest, {}, initialVariables).build();
+				return await this.errorHandler(error, errorContext);
+			} catch (handlerError) {
+				console.error("Error handler failed:", handlerError);
+			}
+			const message = error instanceof Error ? error.message : "Internal Server Error";
+			return this.createErrorResponse(message, 500);
+		}
+	}
+	get fetch() {
+		return (request) => {
+			return this.handle(request);
+		};
+	}
+	createErrorResponse(message, status) {
+		return new Response(JSON.stringify({
+			error: message,
+			status
+		}), {
+			status,
+			headers: { "Content-Type": "application/json" }
+		});
+	}
+};
+
+//#endregion
+export { Router };