faire-auth 1.0.3 → 1.1.0

package/dist/{api-CaRC1Gio.cjs → api-LjfH6hQi.cjs}

@@ -1,34 +1,44 @@
-const require_chunk = require('./chunk-fPmz2rbM.cjs');
-const require_ip = require('./ip-C17Qdq-G.cjs');
-const require_crypto = require('./crypto-DpSCnrTp.cjs');
-const require_json = require('./json--tl7Grvs.cjs');
-const require_cookies = require('./cookies-BTl72THv.cjs');
-const require_middleware = require('./middleware-CWvRH4EW.cjs');
-const require_session = require('./session-Cwrj4GfV.cjs');
-const require_origin_check = require('./origin-check-DjLTuZQ8.cjs');
-const require_email_verification = require('./email-verification-DI_0H4JC.cjs');
-const require_oauth2 = require('./oauth2-5RL4cVNS.cjs');
-const require_state = require('./state-CvSihlVT.cjs');
-const require_social_providers = require('./social-providers-BmFOIIPk.cjs');
-const require_schema = require('./schema-CirKflVs.cjs');
-let __faire_auth_core_env = require("@faire-auth/core/env");
-let __faire_auth_core_error = require("@faire-auth/core/error");
-let __faire_auth_core_factory = require("@faire-auth/core/factory");
-let __faire_auth_core_static = require("@faire-auth/core/static");
-let __faire_auth_core_utils = require("@faire-auth/core/utils");
+const require_rolldown_runtime = require("./rolldown-runtime-C_Pgydhf.cjs");
+require("./hono-pgK4H_U1.cjs");
+const require_oauth2_index = require("./oauth2/index.cjs");
+const require_state = require("./state-2OrNjOO-.cjs");
+const require_cookies = require("./cookies-DQ52rcOy.cjs");
+const require_session = require("./session-CzZSMmQC.cjs");
+const require_social_providers = require("./social-providers-D7w_7Ym8.cjs");
+const require_email_verification = require("./email-verification-DOPnSgbI.cjs");
+const require_json = require("./json-D3aq-nH2.cjs");
+require("./utils-iX0Vy_UL.cjs");
+const require_origin_check = require("./origin-check-BflGhEEN.cjs");
+const require_crypto = require("./crypto-BITfWVwD.cjs");
+const require_schema = require("./schema-b-lKhMkG.cjs");
+const require_ip = require("./ip-DPydExzV.cjs");
+const require_middleware = require("./middleware-Cd-VkNxB.cjs");
+let _faire_auth_core_env = require("@faire-auth/core/env");
+let _faire_auth_core_error = require("@faire-auth/core/error");
+let _faire_auth_core_factory = require("@faire-auth/core/factory");
+let _faire_auth_core_static = require("@faire-auth/core/static");
+let _faire_auth_core_utils = require("@faire-auth/core/utils");
 let hono = require("hono");
 let hono_router_reg_exp_router = require("hono/router/reg-exp-router");
 let zod = require("zod");
-zod = require_chunk.__toESM(zod);
-let __faire_auth_core_db = require("@faire-auth/core/db");
-let __faire_auth_core_crypto = require("@faire-auth/core/crypto");
+zod = require_rolldown_runtime.__toESM(zod, 1);
+let _faire_auth_core_db = require("@faire-auth/core/db");
+let _faire_auth_core_crypto = require("@faire-auth/core/crypto");
 let hono_context_storage = require("hono/context-storage");
-
-//#region src/api/schema/account.ts
+// src/api/schema/account.ts
 const socialProviderListEnum = zod.enum(require_social_providers.social_providers_exports.socialProviderList).or(zod.string());
 const linkAccountSchema = zod.object({
-	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect to after the user has signed in" }),
+	/**
+	* Callback URL to redirect to after the user has signed in.
+	*/
+	callbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect to after the user has signed in" }),
+	/**
+	* OAuth2 provider to use
+	*/
 	provider: socialProviderListEnum,
+	/**
+	* ID Token for direct authentication without redirect
+	*/
 	idToken: zod.object({
 		token: zod.string(),
 		nonce: zod.string().optional(),
@@ -36,8 +46,16 @@ const linkAccountSchema = zod.object({
 		refreshToken: zod.string().optional(),
 		scopes: zod.array(zod.string().min(1)).optional()
 	}).optional(),
+	/**
+	* Additional scopes to request when linking the account.
+	* This is useful for requesting additional permissions when
+	* linking a social account compared to the initial authentication.
+	*/
 	scopes: zod.array(zod.string().min(1)).optional().openapi({ description: "Additional scopes to request when linking the account" }),
-	errorCallbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect to if there is an error during the link process" })
+	/**
+	* The URL to redirect to if there is an error during the link process.
+	*/
+	errorCallbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect to if there is an error during the link process" })
 });
 const unlinkAccountSchema = zod.object({
 	providerId: zod.string(),
@@ -54,42 +72,112 @@ const refreshAccessTokenSchema = zod.object({
 	userId: zod.string().optional().openapi({ description: "The user ID associated with the account" })
 });
 const getAccountInfoSchema = zod.object({ accountId: zod.string().openapi({ description: "The provider given account id for which to get the account info" }) });
-
-//#endregion
-//#region src/api/schema/sign-in.ts
+// src/api/schema/sign-in.ts
 const signInSocialSchema = zod.object({
-	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "Callback URL to redirect to after the user has signed in" }),
-	newUserCallbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true),
-	errorCallbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "Callback URL to redirect to if an error happens" }),
+	/**
+	* Callback URL to redirect to after the user
+	* has signed in.
+	*/
+	callbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "Callback URL to redirect to after the user has signed in" }),
+	/**
+	* callback url to redirect if the user is newly registered.
+	*
+	* useful if you have different routes for existing users and new users
+	*/
+	newUserCallbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true),
+	/**
+	* Callback url to redirect to if an error happens
+	*
+	* If it's initiated from the client sdk this defaults to
+	* the current url.
+	*/
+	errorCallbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "Callback URL to redirect to if an error happens" }),
+	/**
+	* OAuth2 provider to use
+	*/
 	provider: socialProviderListEnum,
+	/**
+	* Disable automatic redirection to the provider
+	*
+	* This is useful if you want to handle the redirection
+	* yourself like in a popup or a different tab.
+	*/
 	disableRedirect: zod.boolean().optional().openapi({ description: "Disable automatic redirection to the provider. Useful for handling the redirection yourself" }),
+	/**
+	* ID token from the provider
+	*
+	* This is used to sign in the user
+	* if the user is already signed in with the
+	* provider in the frontend.
+	*
+	* Only applicable if the provider supports
+	* it. Currently only `apple` and `google` is
+	* supported out of the box.
+	*/
 	idToken: zod.optional(zod.object({
+		/**
+		* ID token from the provider
+		*/
 		token: zod.string().openapi({ description: "ID token from the provider" }),
+		/**
+		* The nonce used to generate the token
+		*/
 		nonce: zod.string().optional().openapi({ description: "Nonce used to generate the token" }),
+		/**
+		* Access token from the provider
+		*/
 		accessToken: zod.string().optional().openapi({ description: "Access token from the provider" }),
+		/**
+		* Refresh token from the provider
+		*/
 		refreshToken: zod.string().optional().openapi({ description: "Refresh token from the provider" }),
+		/**
+		* Expiry date of the token
+		*/
 		expiresAt: zod.number().optional().openapi({ description: "Expiry date of the token" })
 	})).openapi({ description: "ID token from the provider to sign in the user with id token" }),
 	scopes: zod.array(zod.string().min(1)).optional().openapi({ description: "Array of scopes to request from the provider. This will override the default scopes passed." }),
+	/**
+	* Explicitly request sign-up
+	*
+	* Should be used to allow sign up when
+	* disableImplicitSignUp for this provider is
+	* true
+	*/
 	requestSignUp: zod.boolean().optional().openapi({ description: "Explicitly request sign-up. Useful when disableImplicitSignUp is true for this provider" }),
+	/**
+	* The login hint to use for the authorization code request
+	*/
 	loginHint: zod.string().optional().openapi({ description: "The login hint to use for the authorization code request" })
 });
 const signInEmailSchema = zod.object({
-	email: __faire_auth_core_factory.emailSchema.openapi({ description: "Email of the user" }),
-	password: __faire_auth_core_factory.passwordSchema.openapi({ description: "Password of the user" }),
-	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "Callback URL to use as a redirect for email verification" }),
+	/**
+	* Email of the user
+	*/
+	email: _faire_auth_core_factory.emailSchema.openapi({ description: "Email of the user" }),
+	/**
+	* Password of the user
+	*/
+	password: _faire_auth_core_factory.passwordSchema.openapi({ description: "Password of the user" }),
+	/**
+	* Callback URL to use as a redirect for email
+	* verification and for possible redirects
+	*/
+	callbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "Callback URL to use as a redirect for email verification" }),
+	/**
+	* If this is false, the session will not be remembered
+	* @default true
+	*/
 	rememberMe: zod.boolean().default(true).openapi({ description: "If this is false, the session will not be remembered. Default is `true`." })
 });
-
-//#endregion
-//#region src/api/routes/sign-in.ts
-const signInSocialRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.SIGN_IN_SOCIAL,
+// src/api/routes/sign-in.ts
+const signInSocialRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.SIGN_IN_SOCIAL,
 	method: "post",
 	path: "/sign-in/social",
 	description: "Sign in with a social provider",
-	request: (0, __faire_auth_core_factory.req)().bdy(signInSocialSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SIGN_IN_UP].default, "Returns either session details or redirect URL").rdr().err(401, "Invalid token or user not found").err(404, "Provider or id token not supported").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(signInSocialSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SIGN_IN_UP].default, "Returns either session details or redirect URL").rdr().err(401, "Invalid token or user not found").err(404, "Provider or id token not supported").zod().bld()
 });
 const signInSocial = require_session.createEndpoint(signInSocialRoute, (options) => async (ctx) => {
 	const { provider: requestedProvider, idToken, requestSignUp, callbackURL, scopes, loginHint, disableRedirect } = ctx.req.valid("json");
@@ -98,24 +186,24 @@ const signInSocial = require_session.createEndpoint(signInSocialRoute, (options)
 	if (!provider) {
 		context.logger.error("Provider not found. Make sure to add the provider in your auth config", { provider: requestedProvider });
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.PROVIDER_NOT_FOUND
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.PROVIDER_NOT_FOUND
 		}, 404);
 	}
 	if (idToken) {
 		if (!provider.verifyIdToken) {
 			context.logger.error("Provider does not support id token verification", { provider: requestedProvider });
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.ID_TOKEN_NOT_SUPPORTED
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.ID_TOKEN_NOT_SUPPORTED
 			}, 404);
 		}
 		const { token, nonce } = idToken;
 		if (!await provider.verifyIdToken(token, nonce)) {
 			context.logger.error("Invalid id token", { provider: requestedProvider });
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
 			}, 401);
 		}
 		const userInfo = await provider.getUserInfo({
@@ -126,18 +214,18 @@ const signInSocial = require_session.createEndpoint(signInSocialRoute, (options)
 		if (!userInfo?.user) {
 			context.logger.error("Failed to get user info", { provider: requestedProvider });
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_USER_INFO
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_USER_INFO
 			}, 401);
 		}
 		if (userInfo.user.email == null) {
 			context.logger.error("User email not found", { provider: requestedProvider });
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.USER_EMAIL_NOT_FOUND
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.USER_EMAIL_NOT_FOUND
 			}, 401);
 		}
-		const data = await require_oauth2.handleOAuthUserInfo(ctx, {
+		const data = await require_oauth2_index.handleOAuthUserInfo(ctx, {
 			userInfo: {
 				...userInfo.user,
 				email: userInfo.user.email,
@@ -156,13 +244,13 @@ const signInSocial = require_session.createEndpoint(signInSocialRoute, (options)
 		}, options);
 		if (data.type === "redirect") return data.response;
 		if (data.type === "error") return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: data.reason.replaceAll("_", " ")
 		}, 401);
 		await require_cookies.setSessionCookie(ctx, options, data.data);
 		return ctx.render({
-			success: __faire_auth_core_static.True,
-			redirect: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.True,
+			redirect: _faire_auth_core_static.False,
 			token: data.data.session.token,
 			user: data.data.user
 		}, 200);
@@ -176,29 +264,29 @@ const signInSocial = require_session.createEndpoint(signInSocialRoute, (options)
 		...loginHint != null && loginHint !== "" && { loginHint }
 	});
 	if (disableRedirect === true) return ctx.render({
-		success: __faire_auth_core_static.False,
-		redirect: __faire_auth_core_static.False
+		success: _faire_auth_core_static.False,
+		redirect: _faire_auth_core_static.False
 	}, 200);
 	return ctx.render({
-		success: __faire_auth_core_static.False,
-		redirect: __faire_auth_core_static.True,
+		success: _faire_auth_core_static.False,
+		redirect: _faire_auth_core_static.True,
 		url: url.toString()
 	}, 200);
 });
-const signInEmailRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.SIGN_IN_EMAIL,
+const signInEmailRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.SIGN_IN_EMAIL,
 	method: "post",
 	path: "/sign-in/email",
 	description: "Sign in with email and password",
-	request: (0, __faire_auth_core_factory.req)().bdy(signInEmailSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SIGN_IN_UP].default, "Returns either session details or redirect URL").err(400, "Email and password login not enabled in options").err(401, "Invalid email or password").err(403, "Email not verified").zod().err(500, "Failed to create session").bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(signInEmailSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SIGN_IN_UP].default, "Returns either session details or redirect URL").err(400, "Email and password login not enabled in options").err(401, "Invalid email or password").err(403, "Email not verified").zod().err(500, "Failed to create session").bld()
 });
 const signInEmail = require_session.createEndpoint(signInEmailRoute, (options) => async (ctx) => {
 	const context = ctx.get("context");
 	if (!(options.emailAndPassword?.enabled ?? false)) {
 		context.logger.error("Email and password is not enabled. Make sure to enable it in the options on you `auth.ts` file. Check `https://faire-auth.com/docs/authentication/email-password` for more!");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Email and password is not enabled"
 		}, 400);
 	}
@@ -208,24 +296,24 @@ const signInEmail = require_session.createEndpoint(signInEmailRoute, (options) =
 		await context.password.hash(password);
 		context.logger.error("User not found", { email });
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_EMAIL_OR_PASSWORD
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_EMAIL_OR_PASSWORD
 		}, 401);
 	}
 	const credentialAccount = user.accounts.find((a) => a.providerId === "credential");
 	if (!credentialAccount) {
 		context.logger.error("Credential account not found", { email });
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_EMAIL_OR_PASSWORD
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_EMAIL_OR_PASSWORD
 		}, 401);
 	}
 	const currentPassword = credentialAccount.password;
 	if (currentPassword == null) {
 		context.logger.error("Password not found", { email });
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_EMAIL_OR_PASSWORD
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_EMAIL_OR_PASSWORD
 		}, 401);
 	}
 	if (!await context.password.verify({
@@ -234,14 +322,14 @@ const signInEmail = require_session.createEndpoint(signInEmailRoute, (options) =
 	})) {
 		context.logger.error("Invalid password");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_EMAIL_OR_PASSWORD
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_EMAIL_OR_PASSWORD
 		}, 401);
 	}
 	if (options.emailAndPassword?.requireEmailVerification === true && !user.user.emailVerified) {
 		if (!options.emailVerification?.sendVerificationEmail) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.EMAIL_NOT_VERIFIED
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.EMAIL_NOT_VERIFIED
 		}, 403);
 		const token = await require_email_verification.createEmailVerificationToken(context.secret, user.user.email, void 0, options.emailVerification.expiresIn);
 		const url = `${context.baseURL}/verify-email?token=${token}&callbackURL=${callbackURL ?? "/"}`;
@@ -251,16 +339,16 @@ const signInEmail = require_session.createEndpoint(signInEmailRoute, (options) =
 			token
 		}, ctx);
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.EMAIL_NOT_VERIFIED
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.EMAIL_NOT_VERIFIED
 		}, 403);
 	}
 	const session = await context.internalAdapter.createSession(user.user.id, !rememberMe);
 	if (session == null) {
 		context.logger.error("Failed to create session");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION
 		}, 500);
 	}
 	await require_cookies.setSessionCookie(ctx, options, {
@@ -268,22 +356,20 @@ const signInEmail = require_session.createEndpoint(signInEmailRoute, (options) =
 		user: user.user
 	}, !rememberMe);
 	if (callbackURL != null) return ctx.render({
-		success: __faire_auth_core_static.True,
-		redirect: __faire_auth_core_static.True,
+		success: _faire_auth_core_static.True,
+		redirect: _faire_auth_core_static.True,
 		url: callbackURL,
 		token: session.token,
 		user: user.user
 	}, 200);
 	return ctx.render({
-		success: __faire_auth_core_static.True,
-		redirect: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.True,
+		redirect: _faire_auth_core_static.False,
 		token: session.token,
 		user: user.user
 	}, 200);
 });
-
-//#endregion
-//#region src/api/schema/callback.ts
+// src/api/schema/callback.ts
 const callbackSchema = zod.object({
 	code: zod.string(),
 	error: zod.string(),
@@ -300,24 +386,22 @@ const oauthCallbackParamsSchema = zod.object({ id: zod.string().openapi({
 	description: "OAuth provider ID"
 }) });
 const oauthCallbackQuerySchema = callbackSchema;
-
-//#endregion
-//#region src/api/routes/callback.ts
-const handleCallbackOAuth = async (ctx, paramsId, { code, error: error$1, device_id, error_description, state, user } = {}, options) => {
+// src/api/routes/callback.ts
+const handleCallbackOAuth = async (ctx, paramsId, { code, error, device_id, error_description, state, user } = {}, options) => {
 	const context = ctx.get("context");
 	const defaultErrorURL = options.onAPIError?.errorURL ?? `${context.baseURL}/error`;
-	if (error$1 != null) return ctx.redirect(`${defaultErrorURL}?error=${error$1}&error_description=${error_description}`, 302);
+	if (error != null) return ctx.redirect(`${defaultErrorURL}?error=${error}&error_description=${error_description}`, 302);
 	if (state == null) {
-		context.logger.error("State not found", error$1);
+		context.logger.error("State not found", error);
 		return ctx.redirect(`${defaultErrorURL}?error=state_not_found`, 302);
 	}
-	const res$9 = await require_state.parseState(ctx, options);
-	if (res$9.type === "redirect") return res$9.response;
-	const { codeVerifier, callbackURL, link, errorURL, newUserURL, requestSignUp } = res$9.data;
-	const redirectOnError = (error$2) => {
+	const res = await require_state.parseState(ctx, options);
+	if (res.type === "redirect") return res.response;
+	const { codeVerifier, callbackURL, link, errorURL, newUserURL, requestSignUp } = res.data;
+	const redirectOnError = (error) => {
 		let url = errorURL ?? defaultErrorURL;
-		if (url.includes("?")) url = `${url}&error=${error$2}`;
-		else url = `${url}?error=${error$2}`;
+		if (url.includes("?")) url = `${url}&error=${error}`;
+		else url = `${url}?error=${error}`;
 		return ctx.redirect(url, 302);
 	};
 	if (code == null) {
@@ -344,7 +428,7 @@ const handleCallbackOAuth = async (ctx, paramsId, { code, error: error$1, device
 	const userInfo = await provider.getUserInfo({
 		...tokens,
 		...user && { user: require_json.safeJSONParse(user) }
-	}).then((res$10) => res$10?.user);
+	}).then((res) => res?.user);
 	if (!userInfo) {
 		context.logger.error("Unable to get user info");
 		return redirectOnError("unable_to_get_user_info");
@@ -363,8 +447,8 @@ const handleCallbackOAuth = async (ctx, paramsId, { code, error: error$1, device
 			if (existingAccount.userId.toString() !== link.userId.toString()) return redirectOnError("account_already_linked_to_different_user");
 			const updateData = Object.fromEntries(Object.entries({
 				idToken: tokens.idToken,
-				accessToken: await require_oauth2.setTokenUtil(tokens.accessToken, ctx, options),
-				refreshToken: await require_oauth2.setTokenUtil(tokens.refreshToken, ctx, options),
+				accessToken: await require_oauth2_index.setTokenUtil(tokens.accessToken, ctx, options),
+				refreshToken: await require_oauth2_index.setTokenUtil(tokens.refreshToken, ctx, options),
 				accessTokenExpiresAt: tokens.accessTokenExpiresAt,
 				refreshTokenExpiresAt: tokens.refreshTokenExpiresAt,
 				...tokens.scopes && tokens.scopes.length > 0 && { scope: tokens.scopes.join(",") }
@@ -375,23 +459,23 @@ const handleCallbackOAuth = async (ctx, paramsId, { code, error: error$1, device
 			providerId: provider.id,
 			accountId: userInfo.id,
 			...tokens,
-			accessToken: await require_oauth2.setTokenUtil(tokens.accessToken, ctx, options),
-			refreshToken: await require_oauth2.setTokenUtil(tokens.refreshToken, ctx, options),
+			accessToken: await require_oauth2_index.setTokenUtil(tokens.accessToken, ctx, options),
+			refreshToken: await require_oauth2_index.setTokenUtil(tokens.refreshToken, ctx, options),
 			...tokens.scopes && tokens.scopes.length > 0 && { scope: tokens.scopes.join(",") }
 		}) == null) return redirectOnError("unable_to_link_account");
-		let toRedirectTo$1;
+		let toRedirectTo;
 		try {
-			toRedirectTo$1 = callbackURL.toString();
+			toRedirectTo = callbackURL.toString();
 		} catch {
-			toRedirectTo$1 = callbackURL;
+			toRedirectTo = callbackURL;
 		}
-		return ctx.redirect(toRedirectTo$1, 302);
+		return ctx.redirect(toRedirectTo, 302);
 	}
 	if (userInfo.email == null) {
 		context.logger.error("Provider did not return email. This could be due to misconfiguration in the provider settings.");
 		return redirectOnError("email_not_found");
 	}
-	const result = await require_oauth2.handleOAuthUserInfo(ctx, {
+	const result = await require_oauth2_index.handleOAuthUserInfo(ctx, {
 		userInfo: {
 			...userInfo,
 			id: userInfo.id.toString(),
@@ -426,43 +510,41 @@ const handleCallbackOAuth = async (ctx, paramsId, { code, error: error$1, device
 	}
 	return ctx.redirect(toRedirectTo, 302);
 };
-const getOAuthCallbackRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.OAUTH_CALLBACK_GET,
+const getOAuthCallbackRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.OAUTH_CALLBACK_GET,
 	isAction: false,
 	method: "get",
 	path: "/callback/:id",
 	description: "Handle OAuth callback",
-	request: (0, __faire_auth_core_factory.req)().qry(oauthCallbackQuerySchema).prm(oauthCallbackParamsSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)().rdr("Redirect to success or error URL").err(400).bld()
+	request: (0, _faire_auth_core_factory.req)().qry(oauthCallbackQuerySchema).prm(oauthCallbackParamsSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)().rdr("Redirect to success or error URL").err(400).bld()
 });
 const getOAuthCallback = require_session.createEndpoint(getOAuthCallbackRoute, (options) => async (ctx) => {
 	const query = ctx.req.valid("query");
 	const { id: paramsId } = ctx.req.valid("param");
 	return handleCallbackOAuth(ctx, paramsId, query, options);
 });
-const postOAuthCallbackRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.OAUTH_CALLBACK_POST,
+const postOAuthCallbackRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.OAUTH_CALLBACK_POST,
 	isAction: false,
 	method: "post",
 	path: "/callback/:id",
 	description: "Handle OAuth callback (POST)",
-	request: (0, __faire_auth_core_factory.req)().bdy(callbackSchema.optional()).prm(oauthCallbackParamsSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)().rdr("Redirect to success or error URL").err(400).zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(callbackSchema.optional()).prm(oauthCallbackParamsSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)().rdr("Redirect to success or error URL").err(400).zod().bld()
 });
 const postOAuthCallback = require_session.createEndpoint(postOAuthCallbackRoute, (options) => async (ctx) => {
 	const body = ctx.req.valid("json");
 	const { id: paramsId } = ctx.req.valid("param");
 	return handleCallbackOAuth(ctx, paramsId, body, options);
 });
-
-//#endregion
-//#region src/api/routes/sign-out.ts
-const signOutRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.SIGN_OUT,
+// src/api/routes/sign-out.ts
+const signOutRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.SIGN_OUT,
 	method: "post",
 	path: "/sign-out",
 	description: "Sign out the current user",
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default).err(400).bld()
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default).err(400).bld()
 });
 const signOut = require_session.createEndpoint(signOutRoute, (_options) => async (ctx) => {
 	const context = ctx.get("context");
@@ -470,26 +552,33 @@ const signOut = require_session.createEndpoint(signOutRoute, (_options) => async
 	if (sessionCookieToken == null || sessionCookieToken === false) {
 		require_cookies.deleteSessionCookie(ctx);
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_SESSION
 		}, 400);
 	}
 	await context.internalAdapter.deleteSession(sessionCookieToken);
 	require_cookies.deleteSessionCookie(ctx);
-	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+	return ctx.render({ success: _faire_auth_core_static.True }, 200);
 });
-
-//#endregion
-//#region src/api/schema/reset-password.ts
+// src/api/schema/reset-password.ts
 const requestPasswordResetSchema = zod.object({
-	email: __faire_auth_core_factory.emailSchema.openapi({ description: "The email address of the user to send the password reset email to" }),
-	redirectTo: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect the user to reset their password. If the token isn't valid or expired, it'll be redirected with a query parameter `?error=INVALID_TOKEN`. If the token is valid, it'll be redirected with a query parameter `?token=VALID_TOKEN`" })
+	/**
+	* The email address of the user to send the password reset email to.
+	*/
+	email: _faire_auth_core_factory.emailSchema.openapi({ description: "The email address of the user to send the password reset email to" }),
+	/**
+	* The URL to redirect the user to reset their password.
+	* If the token isn't valid or expired, it'll be redirected with a query parameter `?
+	* error=INVALID_TOKEN`. If the token is valid, it'll be redirected with a query parameter `?
+	* token=VALID_TOKEN
+	*/
+	redirectTo: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect the user to reset their password. If the token isn't valid or expired, it'll be redirected with a query parameter `?error=INVALID_TOKEN`. If the token is valid, it'll be redirected with a query parameter `?token=VALID_TOKEN`" })
 });
 const requestPasswordResetCallbackParamsSchema = zod.object({ token: zod.string().openapi({ param: {
 	in: "path",
 	name: "token"
 } }) });
-const requestPasswordResetCallbackQuerySchema = zod.object({ callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)().openapi({
+const requestPasswordResetCallbackQuerySchema = zod.object({ callbackURL: (0, _faire_auth_core_factory.callbackURLSchema)().openapi({
 	param: {
 		in: "query",
 		name: "callbackURL"
@@ -497,16 +586,14 @@ const requestPasswordResetCallbackQuerySchema = zod.object({ callbackURL: (0, __
 	description: "The URL to redirect the user to reset their password"
 }) });
 const resetPasswordSchema = zod.object({
-	newPassword: __faire_auth_core_factory.passwordSchema.openapi({ description: "The new password to set" }),
+	newPassword: _faire_auth_core_factory.passwordSchema.openapi({ description: "The new password to set" }),
 	token: zod.string().optional().openapi({ description: "The token to reset the password" })
 });
 const resetPasswordQuerySchema = zod.object({ token: zod.string().optional().openapi({ param: {
 	in: "query",
 	name: "token"
 } }) });
-
-//#endregion
-//#region src/api/routes/reset-password.ts
+// src/api/routes/reset-password.ts
 const redirectError = (ctx, callbackURL, query) => {
 	const url = callbackURL != null ? new URL(callbackURL, ctx.get("context").baseURL) : new URL(`${ctx.get("context").baseURL}/error`);
 	if (query) Object.entries(query).forEach(([k, v]) => url.searchParams.set(k, v));
@@ -517,20 +604,20 @@ const redirectCallback = (ctx, callbackURL, query) => {
 	if (query) Object.entries(query).forEach(([k, v]) => url.searchParams.set(k, v));
 	return url.href;
 };
-const requestPasswordResetRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.REQUEST_PASSWORD_RESET,
+const requestPasswordResetRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.REQUEST_PASSWORD_RESET,
 	method: "post",
 	path: "/request-password-reset",
 	description: "Send a password reset email to the user",
-	request: (0, __faire_auth_core_factory.req)().bdy(requestPasswordResetSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default).err(400, "Reset password not enabled in options").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(requestPasswordResetSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default).err(400, "Reset password not enabled in options").zod().bld()
 });
 const requestPasswordReset = require_session.createEndpoint(requestPasswordResetRoute, (options) => async (ctx) => {
 	const context = ctx.get("context");
 	if (!options.emailAndPassword?.sendResetPassword) {
 		context.logger.error("Reset password isn't enabled. Please add an emailAndPassword and sendResetPassword function to your auth config!");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Reset password isn't enabled"
 		}, 400);
 	}
@@ -539,12 +626,12 @@ const requestPasswordReset = require_session.createEndpoint(requestPasswordReset
 	if (!user) {
 		context.logger.error("Reset Password: User not found", { email });
 		return ctx.render({
-			success: __faire_auth_core_static.True,
+			success: _faire_auth_core_static.True,
 			message: "If this email exists in our system, check your email for the reset link"
 		}, 200);
 	}
-	const expiresAt = (0, __faire_auth_core_utils.getDate)(options.emailAndPassword.resetPasswordTokenExpiresIn ?? 3600 * 1, "sec");
-	const verificationToken = (0, __faire_auth_core_crypto.generateId)(24);
+	const expiresAt = (0, _faire_auth_core_utils.getDate)(options.emailAndPassword.resetPasswordTokenExpiresIn ?? 3600, "sec");
+	const verificationToken = (0, _faire_auth_core_crypto.generateId)(24);
 	await context.internalAdapter.createVerificationValue({
 		value: user.user.id,
 		identifier: `reset-password:${verificationToken}`,
@@ -557,16 +644,16 @@ const requestPasswordReset = require_session.createEndpoint(requestPasswordReset
 		url,
 		token: verificationToken
 	}, ctx);
-	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+	return ctx.render({ success: _faire_auth_core_static.True }, 200);
 });
-const requestPasswordResetCallbackRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.REQUEST_PASSWORD_RESET_CALLBACK,
+const requestPasswordResetCallbackRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.REQUEST_PASSWORD_RESET_CALLBACK,
 	method: "get",
 	path: "/reset-password/:token",
 	description: "Redirects the user to the callback URL with the token",
 	middleware: [require_origin_check.originCheck((ctx) => ctx.req.query("callbackURL"))],
-	request: (0, __faire_auth_core_factory.req)().prm(requestPasswordResetCallbackParamsSchema).qry(requestPasswordResetCallbackQuerySchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)().rdr().bld()
+	request: (0, _faire_auth_core_factory.req)().prm(requestPasswordResetCallbackParamsSchema).qry(requestPasswordResetCallbackQuerySchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)().rdr().bld()
 });
 const requestPasswordResetCallback = require_session.createEndpoint(requestPasswordResetCallbackRoute, (_options) => async (ctx) => {
 	const { token } = ctx.req.valid("param");
@@ -576,37 +663,37 @@ const requestPasswordResetCallback = require_session.createEndpoint(requestPassw
 	if (!verification || verification.expiresAt < /* @__PURE__ */ new Date()) return ctx.redirect(redirectError(ctx, callbackURL, { error: "INVALID_TOKEN" }), 302);
 	return ctx.redirect(redirectCallback(ctx, callbackURL, { token }), 302);
 });
-const resetPasswordRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.RESET_PASSWORD,
+const resetPasswordRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.RESET_PASSWORD,
 	method: "post",
 	path: "/reset-password",
 	description: "Reset the password for a user",
-	request: (0, __faire_auth_core_factory.req)().qry(resetPasswordQuerySchema).bdy(resetPasswordSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default).err(400, "Invalid token or password").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().qry(resetPasswordQuerySchema).bdy(resetPasswordSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default).err(400, "Invalid token or password").zod().bld()
 });
 const resetPassword = require_session.createEndpoint(resetPasswordRoute, (options) => async (ctx) => {
 	const token = ctx.req.valid("json").token || ctx.req.valid("query").token;
 	if (token == null || token === "") return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
 	}, 400);
 	const { newPassword } = ctx.req.valid("json");
 	const context = ctx.get("context");
 	const minLength = context.password.config.minPasswordLength;
 	const maxLength = context.password.config.maxPasswordLength;
 	if (newPassword.length < minLength) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_SHORT
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_SHORT
 	}, 400);
 	if (newPassword.length > maxLength) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_LONG
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_LONG
 	}, 400);
 	const id = `reset-password:${token}`;
 	const verification = await context.internalAdapter.findVerificationValue(id);
 	if (!verification || verification.expiresAt < /* @__PURE__ */ new Date()) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
 	}, 400);
 	const userId = verification.value;
 	const hashedPassword = await context.password.hash(newPassword);
@@ -623,12 +710,10 @@ const resetPassword = require_session.createEndpoint(resetPasswordRoute, (option
 		if (user) await options.emailAndPassword.onPasswordReset({ user }, ctx.req);
 	}
 	if (options.emailAndPassword?.revokeSessionsOnPasswordReset) await context.internalAdapter.deleteSessions(userId);
-	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+	return ctx.render({ success: _faire_auth_core_static.True }, 200);
 });
-
-//#endregion
-//#region src/api/schema/update-user.ts
-const updateUserSchema = __faire_auth_core_db.looseUserSchema.omit({
+// src/api/schema/update-user.ts
+const updateUserSchema = _faire_auth_core_db.looseUserSchema.omit({
 	id: true,
 	createdAt: true,
 	updatedAt: true,
@@ -636,14 +721,35 @@ const updateUserSchema = __faire_auth_core_db.looseUserSchema.omit({
 	email: true
 });
 const changePasswordSchema = zod.object({
-	newPassword: __faire_auth_core_factory.passwordSchema.openapi({ description: "The new password to set" }),
-	currentPassword: __faire_auth_core_factory.passwordSchema.openapi({ description: "The current password" }),
+	/**
+	* The new password to set
+	*/
+	newPassword: _faire_auth_core_factory.passwordSchema.openapi({ description: "The new password to set" }),
+	/**
+	* The current password of the user
+	*/
+	currentPassword: _faire_auth_core_factory.passwordSchema.openapi({ description: "The current password" }),
+	/**
+	* revoke all sessions that are not the
+	* current one logged in by the user
+	*/
 	revokeOtherSessions: zod.boolean().optional().openapi({ description: "Revoke all other sessions" })
 });
-const setPasswordSchema = zod.object({ newPassword: __faire_auth_core_factory.passwordSchema });
+const setPasswordSchema = zod.object({ newPassword: _faire_auth_core_factory.passwordSchema });
 const deleteUserSchema = zod.object({
-	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The callback URL to redirect to after the user is deleted" }),
-	password: __faire_auth_core_factory.passwordSchema.optional().openapi({ description: "The password of the user. If the password isn't provided, session freshness will be checked." }),
+	/**
+	* The callback URL to redirect to after the user is deleted
+	* this is only used on delete user callback
+	*/
+	callbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The callback URL to redirect to after the user is deleted" }),
+	/**
+	* The password of the user. If the password isn't provided, session freshness
+	* will be checked.
+	*/
+	password: _faire_auth_core_factory.passwordSchema.optional().openapi({ description: "The password of the user. If the password isn't provided, session freshness will be checked." }),
+	/**
+	* The token to delete the user. If the token is provided, the user will be deleted
+	*/
 	token: zod.string().optional().openapi({ description: "The token to delete the user. If the token is provided, the user will be deleted" })
 });
 const deleteUserCallbackQuerySchema = zod.object({
@@ -651,30 +757,28 @@ const deleteUserCallbackQuerySchema = zod.object({
 		in: "query",
 		name: "token"
 	} }),
-	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ param: {
+	callbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ param: {
 		in: "query",
 		name: "callbackURL"
 	} })
 });
 const changeEmailSchema = zod.object({
-	newEmail: __faire_auth_core_factory.emailSchema.openapi({ description: "The new email to set" }),
-	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect to after email verification" })
+	newEmail: _faire_auth_core_factory.emailSchema.openapi({ description: "The new email to set" }),
+	callbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to redirect to after email verification" })
 });
-
-//#endregion
-//#region src/api/routes/update-user.ts
-const updateUserRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.UPDATE_USER,
+// src/api/routes/update-user.ts
+const updateUserRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.UPDATE_USER,
 	method: "post",
 	path: "/update-user",
 	description: "Update the current user",
 	middleware: [require_session.sessionMiddleware()],
-	request: (0, __faire_auth_core_factory.req)().bdy(updateUserSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default).zod().err(500, "Failed to update user").bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(updateUserSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default).zod().err(500, "Failed to update user").bld()
 });
 const updateUser = require_session.createEndpoint(updateUserRoute, (options) => async (ctx) => {
-	const { name, image,...rest } = ctx.req.valid("json");
-	if (image === void 0 && name === void 0 && Object.keys(rest).length === 0) return ctx.render({ success: __faire_auth_core_static.True }, 200);
+	const { name, image, ...rest } = ctx.req.valid("json");
+	if (image === void 0 && name === void 0 && Object.keys(rest).length === 0) return ctx.render({ success: _faire_auth_core_static.True }, 200);
 	const context = ctx.get("context");
 	const session = ctx.get("session");
 	const additionalFields = await require_schema.parseUserInput(options, rest, "update");
@@ -685,8 +789,8 @@ const updateUser = require_session.createEndpoint(updateUserRoute, (options) =>
 		...additionalFields
 	});
 	if (user == null) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_UPDATE_USER
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_UPDATE_USER
 	}, 500);
 	/**
 	* Update the session cookie with the new user data
@@ -695,58 +799,58 @@ const updateUser = require_session.createEndpoint(updateUserRoute, (options) =>
 		session: session.session,
 		user
 	});
-	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+	return ctx.render({ success: _faire_auth_core_static.True }, 200);
 });
-const changePasswordRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.CHANGE_PASSWORD,
+const changePasswordRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.CHANGE_PASSWORD,
 	method: "post",
 	path: "/change-password",
 	description: "Change the password of the user",
 	middleware: [require_session.sensitiveSessionMiddleware],
-	request: (0, __faire_auth_core_factory.req)().bdy(changePasswordSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SIGN_IN_UP].default).err(400, "Invalid password").err(404, "Account not found").zod().err(500, "Failed to get session").bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(changePasswordSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SIGN_IN_UP].default).err(400, "Invalid password").err(404, "Account not found").zod().err(500, "Failed to get session").bld()
 });
 const changePassword = require_session.createEndpoint(changePasswordRoute, (options) => async (ctx) => {
 	const context = ctx.get("context");
 	const session = ctx.get("session");
-	const { newPassword, currentPassword, revokeOtherSessions: revokeOtherSessions$1 } = ctx.req.valid("json");
+	const { newPassword, currentPassword, revokeOtherSessions } = ctx.req.valid("json");
 	const { minPasswordLength } = context.password.config;
 	if (newPassword.length < minPasswordLength) {
 		context.logger.error("Password is too short");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_SHORT
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_SHORT
 		}, 400);
 	}
 	const { maxPasswordLength } = context.password.config;
 	if (newPassword.length > maxPasswordLength) {
 		context.logger.error("Password is too long");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_LONG
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_LONG
 		}, 400);
 	}
-	const account = (await context.internalAdapter.findAccounts(session.user.id)).find((account$1) => account$1.providerId === "credential" && account$1.password != null);
+	const account = (await context.internalAdapter.findAccounts(session.user.id)).find((account) => account.providerId === "credential" && account.password != null);
 	if (account?.password == null) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.CREDENTIAL_ACCOUNT_NOT_FOUND
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.CREDENTIAL_ACCOUNT_NOT_FOUND
 	}, 404);
 	const passwordHash = await context.password.hash(newPassword);
 	if (!await context.password.verify({
 		hash: account.password,
 		password: currentPassword
 	})) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_PASSWORD
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_PASSWORD
 	}, 400);
 	await context.internalAdapter.updateAccount(account.id, { password: passwordHash });
 	let token = session.session.token;
-	if (revokeOtherSessions$1 === true) {
+	if (revokeOtherSessions === true) {
 		await context.internalAdapter.deleteSessions(session.user.id);
 		const newSession = await context.internalAdapter.createSession(session.user.id);
 		if (newSession == null) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_SESSION
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_SESSION
 		}, 500);
 		await require_cookies.setSessionCookie(ctx, options, {
 			session: newSession,
@@ -755,21 +859,21 @@ const changePassword = require_session.createEndpoint(changePasswordRoute, (opti
 		token = newSession.token;
 	}
 	return ctx.render({
-		redirect: __faire_auth_core_static.False,
-		success: __faire_auth_core_static.True,
+		redirect: _faire_auth_core_static.False,
+		success: _faire_auth_core_static.True,
 		token,
 		user: session.user
 	}, 200);
 });
-const setPasswordRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.SET_PASSWORD,
+const setPasswordRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.SET_PASSWORD,
 	hide: true,
 	SERVER_ONLY: true,
 	method: "post",
 	path: "/set-password",
 	middleware: [require_session.sensitiveSessionMiddleware],
-	request: (0, __faire_auth_core_factory.req)().bdy(setPasswordSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default).err(400, "Invalid password or user already has password").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(setPasswordSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default).err(400, "Invalid password or user already has password").zod().bld()
 });
 const setPassword = require_session.createEndpoint(setPasswordRoute, (_options) => async (ctx) => {
 	const context = ctx.get("context");
@@ -779,19 +883,19 @@ const setPassword = require_session.createEndpoint(setPasswordRoute, (_options)
 	if (newPassword.length < minPasswordLength) {
 		context.logger.error("Password is too short");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_SHORT
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_SHORT
 		}, 400);
 	}
 	const { maxPasswordLength } = context.password.config;
 	if (newPassword.length > maxPasswordLength) {
 		context.logger.error("Password is too long");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_LONG
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_LONG
 		}, 400);
 	}
-	const account = (await context.internalAdapter.findAccounts(session.user.id)).find((account$1) => account$1.providerId === "credential" && account$1.password != null);
+	const account = (await context.internalAdapter.findAccounts(session.user.id)).find((account) => account.providerId === "credential" && account.password != null);
 	const passwordHash = await context.password.hash(newPassword);
 	if (!account) {
 		await context.internalAdapter.linkAccount({
@@ -800,28 +904,28 @@ const setPassword = require_session.createEndpoint(setPasswordRoute, (_options)
 			accountId: session.user.id,
 			password: passwordHash
 		});
-		return ctx.render({ success: __faire_auth_core_static.True }, 200);
+		return ctx.render({ success: _faire_auth_core_static.True }, 200);
 	}
 	return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: "User already has a password"
 	}, 400);
 });
-const deleteUserRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.DELETE_USER,
+const deleteUserRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.DELETE_USER,
 	method: "post",
 	path: "/delete-user",
 	description: "Delete the user",
 	middleware: [require_session.sensitiveSessionMiddleware],
-	request: (0, __faire_auth_core_factory.req)().bdy(deleteUserSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default, "User deletion processed successfully").rdr("Redirect to callback URL").err(400, "Account not found or invalid password").err(404, "Delete user is disabled").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(deleteUserSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default, "User deletion processed successfully").rdr("Redirect to callback URL").err(400, "Account not found or invalid password").err(404, "Delete user is disabled").zod().bld()
 });
 const deleteUser = require_session.createEndpoint(deleteUserRoute, (options) => async (ctx) => {
 	const context = ctx.get("context");
 	if (options.user?.deleteUser?.enabled !== true) {
 		context.logger.error("Delete user is disabled. Enable it in the options");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Delete user is disabled"
 		}, 404);
 	}
@@ -829,41 +933,41 @@ const deleteUser = require_session.createEndpoint(deleteUserRoute, (options) =>
 	const api = ctx.get("api");
 	const { callbackURL, password, token } = ctx.req.valid("json");
 	let canDelete = false;
-	const account = (await context.internalAdapter.findAccounts(session.user.id)).find((account$1) => account$1.providerId === "credential" && account$1.password != null);
+	const account = (await context.internalAdapter.findAccounts(session.user.id)).find((account) => account.providerId === "credential" && account.password != null);
 	if (password != null) {
 		if (account?.password == null) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.CREDENTIAL_ACCOUNT_NOT_FOUND
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.CREDENTIAL_ACCOUNT_NOT_FOUND
 		}, 400);
 		if (!await context.password.verify({
 			hash: account.password,
 			password
 		})) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_PASSWORD
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_PASSWORD
 		}, 400);
 		canDelete = true;
 	}
-	if (token != null) return await api.deleteUserCallback({ query: { token } }, ctx).then((res$9) => res$9 instanceof Response ? res$9 : ctx.render(res$9, res$9.success === true ? 200 : "errors" in res$9 ? 422 : 404));
+	if (token != null) return await api.deleteUserCallback({ query: { token } }, ctx).then((res) => res instanceof Response ? res : ctx.render(res, res.success === true ? 200 : "errors" in res ? 422 : 404));
 	if (options.user?.deleteUser?.sendDeleteAccountVerification != null) {
 		if (account?.password != null && !canDelete) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.USER_ALREADY_HAS_PASSWORD
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.USER_ALREADY_HAS_PASSWORD
 		}, 400);
-		const token$1 = (0, require_crypto.crypto_exports.generateRandomString)(32, "0-9", "a-z");
+		const token = (0, require_crypto.crypto_exports.generateRandomString)(32, "0-9", "a-z");
 		await context.internalAdapter.createVerificationValue({
 			value: session.user.id,
-			identifier: `delete-account-${token$1}`,
-			expiresAt: new Date(Date.now() + (options.user.deleteUser.deleteTokenExpiresIn ?? 3600 * 24) * 1e3)
+			identifier: `delete-account-${token}`,
+			expiresAt: new Date(Date.now() + (options.user.deleteUser.deleteTokenExpiresIn ?? 86400) * 1e3)
 		});
-		const url = `${context.baseURL}/delete-user/callback?token=${token$1}${callbackURL ? `&callbackURL=${callbackURL}` : ""}`;
+		const url = `${context.baseURL}/delete-user/callback?token=${token}${callbackURL ? `&callbackURL=${callbackURL}` : ""}`;
 		await options.user.deleteUser.sendDeleteAccountVerification({
 			user: session.user,
 			url,
-			token: token$1
+			token
 		}, ctx);
 		return ctx.render({
-			success: __faire_auth_core_static.True,
+			success: _faire_auth_core_static.True,
 			message: "Verification email sent"
 		}, 200);
 	}
@@ -871,13 +975,13 @@ const deleteUser = require_session.createEndpoint(deleteUserRoute, (options) =>
 		const currentAge = session.session.createdAt.getTime();
 		const freshAge = context.sessionConfig.freshAge * 1e3;
 		if (Date.now() - currentAge > freshAge * 1e3) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.SESSION_EXPIRED
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.SESSION_EXPIRED
 		}, 400);
 		canDelete = true;
 	}
 	if (!canDelete) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: "User cannot be deleted. please provide a password or token"
 	}, 400);
 	if (options.user?.deleteUser?.beforeDelete) await options.user.deleteUser.beforeDelete(session.user, ctx.req);
@@ -887,25 +991,25 @@ const deleteUser = require_session.createEndpoint(deleteUserRoute, (options) =>
 	require_cookies.deleteSessionCookie(ctx);
 	if (options.user?.deleteUser?.afterDelete) await options.user.deleteUser.afterDelete(session.user, ctx.req);
 	return ctx.render({
-		success: __faire_auth_core_static.True,
+		success: _faire_auth_core_static.True,
 		message: "User deleted"
 	}, 200);
 });
-const deleteUserCallbackRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.DELETE_USER_CALLBACK,
+const deleteUserCallbackRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.DELETE_USER_CALLBACK,
 	method: "get",
 	path: "/delete-user/callback",
 	description: "Callback to complete user deletion with verification token",
 	middleware: [require_origin_check.originCheck((ctx) => ctx.req.query("callbackURL")), require_session.sessionMiddleware()],
-	request: (0, __faire_auth_core_factory.req)().qry(deleteUserCallbackQuerySchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default, "User successfully deleted").rdr("Redirect to callback URL").err(404, "Invalid token or delete user is disabled").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().qry(deleteUserCallbackQuerySchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default, "User successfully deleted").rdr("Redirect to callback URL").err(404, "Invalid token or delete user is disabled").zod().bld()
 });
 const deleteUserCallback = require_session.createEndpoint(deleteUserCallbackRoute, (options) => async (ctx) => {
 	const context = ctx.get("context");
 	if (!(options.user?.deleteUser?.enabled ?? false)) {
 		context.logger.error("Delete user is disabled. Enable it in the options");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Delete user is disabled"
 		}, 404);
 	}
@@ -915,13 +1019,13 @@ const deleteUserCallback = require_session.createEndpoint(deleteUserCallbackRout
 	if (!token || token.expiresAt < /* @__PURE__ */ new Date()) {
 		context.logger.info(requestedToken);
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
 		}, 404);
 	}
 	if (token.value !== session.user.id) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
 	}, 404);
 	const { beforeDelete } = options.user?.deleteUser ?? {};
 	if (beforeDelete) await beforeDelete(session.user, ctx.req);
@@ -934,24 +1038,24 @@ const deleteUserCallback = require_session.createEndpoint(deleteUserCallbackRout
 	if (afterDelete) await afterDelete(session.user, ctx.req);
 	if (callbackURL != null) return ctx.redirect(callbackURL);
 	return ctx.render({
-		success: __faire_auth_core_static.True,
+		success: _faire_auth_core_static.True,
 		message: "User deleted"
 	}, 200);
 });
-const changeEmailRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.CHANGE_EMAIL,
+const changeEmailRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.CHANGE_EMAIL,
 	method: "post",
 	path: "/change-email",
 	middleware: [require_session.sensitiveSessionMiddleware],
-	request: (0, __faire_auth_core_factory.req)().bdy(changeEmailSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default, "Email change request processed successfully").err(400, "Change email is disabled or user already exists").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(changeEmailSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default, "Email change request processed successfully").err(400, "Change email is disabled or user already exists").zod().bld()
 });
 const changeEmail = require_session.createEndpoint(changeEmailRoute, (options) => async (ctx) => {
 	const context = ctx.get("context");
 	if (options.user?.changeEmail?.enabled !== true) {
 		context.logger.error("Change email is disabled.");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Change email is disabled"
 		}, 400);
 	}
@@ -961,14 +1065,14 @@ const changeEmail = require_session.createEndpoint(changeEmailRoute, (options) =
 	if (newEmail === session.user.email) {
 		context.logger.error("Email is the same");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Email is the same"
 		}, 400);
 	}
 	if (await context.internalAdapter.findUserByEmail(newEmail)) {
 		context.logger.error("Email already exists");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Couldn't update your email"
 		}, 400);
 	}
@@ -977,8 +1081,8 @@ const changeEmail = require_session.createEndpoint(changeEmailRoute, (options) =
 	*/
 	if (!session.user.emailVerified) {
 		if (await context.internalAdapter.findUserByEmail(newEmail)) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.USER_ALREADY_EXISTS
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.USER_ALREADY_EXISTS
 		}, 400);
 		await context.internalAdapter.updateUserByEmail(session.user.email, {
 			email: newEmail,
@@ -992,15 +1096,15 @@ const changeEmail = require_session.createEndpoint(changeEmailRoute, (options) =
 			}
 		});
 		if (options.emailVerification?.sendVerificationEmail) {
-			const token$1 = await require_email_verification.createEmailVerificationToken(context.secret, newEmail, void 0, options.emailVerification.expiresIn);
-			const url$1 = `${context.baseURL}/verify-email?token=${token$1}&callbackURL=${callbackURL ?? "/"}`;
+			const token = await require_email_verification.createEmailVerificationToken(context.secret, newEmail, void 0, options.emailVerification.expiresIn);
+			const url = `${context.baseURL}/verify-email?token=${token}&callbackURL=${callbackURL ?? "/"}`;
 			await options.emailVerification.sendVerificationEmail({
 				user: session.user,
-				url: url$1,
-				token: token$1
+				url,
+				token
 			}, ctx);
 		}
-		return ctx.render({ success: __faire_auth_core_static.True }, 200);
+		return ctx.render({ success: _faire_auth_core_static.True }, 200);
 	}
 	/**
 	* If the email is verified, we need to send a verification email
@@ -1008,7 +1112,7 @@ const changeEmail = require_session.createEndpoint(changeEmailRoute, (options) =
 	if (options.user?.changeEmail?.sendChangeEmailVerification == null) {
 		context.logger.error("Verification email isn't enabled.");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Verification email isn't enabled"
 		}, 400);
 	}
@@ -1020,11 +1124,9 @@ const changeEmail = require_session.createEndpoint(changeEmailRoute, (options) =
 		url,
 		token
 	}, ctx);
-	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+	return ctx.render({ success: _faire_auth_core_static.True }, 200);
 });
-
-//#endregion
-//#region src/api/routes/error.ts
+// src/api/routes/error.ts
 const sanitize = (input) => input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
 const html = (errorCode = "Unknown", errorDescription) => `<!DOCTYPE html>
 <html lang="en">
@@ -1117,83 +1219,97 @@ const errorQuerySchema = zod.object({
 	error: zod.string().optional(),
 	error_description: zod.string().optional()
 });
-const errorRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.ERROR,
+const errorRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.ERROR,
 	hide: true,
 	isAction: false,
 	method: "get",
 	path: "/error",
 	description: "Displays an error page",
-	request: (0, __faire_auth_core_factory.req)().qry(errorQuerySchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(zod.string().openapi({ description: "The HTML content of the error page" }), "A HTML error page", "text/html").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().qry(errorQuerySchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(zod.string().openapi({ description: "The HTML content of the error page" }), "A HTML error page", "text/html").zod().bld()
 });
 const error = require_session.createEndpoint(errorRoute, (_options) => async (ctx) => {
-	const { error: error$1, error_description: _error_description } = ctx.req.valid("query");
-	return ctx.html(html(error$1), 200);
+	const { error, error_description: _error_description } = ctx.req.valid("query");
+	return ctx.html(html(error), 200);
 });
-
-//#endregion
-//#region src/api/routes/ok.ts
-const okRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.OK,
+// src/api/routes/ok.ts
+const okRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.OK,
 	hide: true,
 	isAction: false,
 	method: "get",
 	path: "/ok",
 	description: "Check if the API is working",
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default, "API is working").bld()
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default, "API is working").bld()
 });
-const ok = require_session.createEndpoint(okRoute, (_options) => async (ctx) => ctx.render({ success: __faire_auth_core_static.True }, 200));
-
-//#endregion
-//#region src/api/schema/sign-up.ts
+const ok = require_session.createEndpoint(okRoute, (_options) => async (ctx) => ctx.render({ success: _faire_auth_core_static.True }, 200));
+// src/api/schema/sign-up.ts
 const signUpEmailSchema = zod.looseObject({
-	name: __faire_auth_core_factory.nameSchema,
-	email: __faire_auth_core_factory.emailSchema.openapi({ description: "The email of the user" }),
-	password: __faire_auth_core_factory.passwordSchema.openapi({ description: "The password of the user" }),
+	/**
+	* Name of the user
+	*/
+	name: _faire_auth_core_factory.nameSchema,
+	/**
+	* Email of the user
+	*/
+	email: _faire_auth_core_factory.emailSchema.openapi({ description: "The email of the user" }),
+	/**
+	* Password of the user
+	*/
+	password: _faire_auth_core_factory.passwordSchema.openapi({ description: "The password of the user" }),
+	/**
+	* Image url for the user
+	*/
 	image: zod.url().nullish().openapi({ description: "The profile image URL of the user" }),
-	callbackURL: (0, __faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to use for email verification callback" }),
+	/**
+	* Callback URL to use as a redirect for email
+	* verification and for possible redirects
+	*/
+	callbackURL: (0, _faire_auth_core_factory.callbackURLSchema)(true).openapi({ description: "The URL to use for email verification callback" }),
+	/**
+	* If this is false, the session will not be remembered
+	* @default true
+	*/
 	rememberMe: zod.boolean().default(true).openapi({ description: "If this is false, the session will not be remembered. Default is `true`." })
 });
-
-//#endregion
-//#region src/api/routes/sign-up.ts
-const signUpEmailRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.SIGN_UP_EMAIL,
+// src/api/routes/sign-up.ts
+const signUpEmailRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.SIGN_UP_EMAIL,
 	method: "post",
 	path: "/sign-up/email",
 	description: "Sign up a user using email and password",
-	request: (0, __faire_auth_core_factory.req)().bdy(signUpEmailSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SIGN_IN_UP].default, "Successfully created user").err(400, "Email and password sign up is not enabled, invalid password, or user already exists").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(signUpEmailSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SIGN_IN_UP].default, "Successfully created user").err(400, "Email and password sign up is not enabled, invalid password, or user already exists").zod().bld()
 });
 const signUpEmail = require_session.createEndpoint(signUpEmailRoute, (options) => async (ctx) => {
 	if (!(options.emailAndPassword?.enabled ?? false) || options.emailAndPassword?.disableSignUp === true) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: "Email and password sign up is not enabled"
 	}, 400);
-	const { name, email, password, image, callbackURL, rememberMe,...additionalFields } = ctx.req.valid("json");
+	const { name, email, password, image, callbackURL, rememberMe, ...additionalFields } = ctx.req.valid("json");
 	const context = ctx.get("context");
 	const { minPasswordLength, maxPasswordLength } = context.password.config;
 	if (password.length < minPasswordLength) {
 		context.logger.error("Password is too short");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_SHORT
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_SHORT
 		}, 400);
 	}
 	if (password.length > maxPasswordLength) {
 		context.logger.error("Password is too long");
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_LONG
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.PASSWORD_TOO_LONG
 		}, 400);
 	}
 	return require_ip.runWithTransaction(context.adapter, async () => {
 		if ((await context.internalAdapter.findUserByEmail(email))?.user) {
 			context.logger.info(`Sign-up attempt for existing email: ${email}`);
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.USER_ALREADY_EXISTS
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.USER_ALREADY_EXISTS
 			}, 400);
 		}
 		const additionalData = await require_schema.parseUserInput(options, additionalFields, "create");
@@ -1217,15 +1333,15 @@ const signUpEmail = require_session.createEndpoint(signUpEmailRoute, (options) =
 				emailVerified: false
 			});
 		} catch (e) {
-			if ((0, __faire_auth_core_env.isDevelopment)()) context.logger.error("Failed to create user", e);
+			if ((0, _faire_auth_core_env.isDevelopment)()) context.logger.error("Failed to create user", e);
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_USER
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_USER
 			}, 400);
 		}
 		if (createdUser == null) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_USER
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_USER
 		}, 400);
 		await context.internalAdapter.linkAccount({
 			userId: createdUser.id,
@@ -1243,37 +1359,35 @@ const signUpEmail = require_session.createEndpoint(signUpEmailRoute, (options) =
 			}, ctx);
 		}
 		if (options.emailAndPassword?.autoSignIn === false || options.emailAndPassword?.requireEmailVerification === true) return ctx.render({
-			success: __faire_auth_core_static.True,
-			redirect: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.True,
+			redirect: _faire_auth_core_static.False,
 			user: createdUser
 		}, 200);
 		const session = await context.internalAdapter.createSession(createdUser.id, rememberMe === false);
 		if (session == null) return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION
 		}, 400);
 		await require_cookies.setSessionCookie(ctx, options, {
 			session,
 			user: createdUser
 		}, rememberMe === false);
 		return ctx.render({
-			success: __faire_auth_core_static.True,
-			redirect: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.True,
+			redirect: _faire_auth_core_static.False,
 			token: session.token,
 			user: createdUser
 		}, 200);
 	});
 });
-
-//#endregion
-//#region src/api/routes/account.ts
-const listAccountsRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.LIST_ACCOUNTS,
+// src/api/routes/account.ts
+const listAccountsRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.LIST_ACCOUNTS,
 	method: "get",
 	path: "/list-accounts",
 	description: "List all accounts linked to the user",
 	middleware: [require_session.sessionMiddleware()],
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.ACCOUNTS_LIST].default).bld()
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.ACCOUNTS_LIST].default).bld()
 });
 const listAccounts = require_session.createEndpoint(listAccountsRoute, (_options) => async (ctx) => {
 	const context = ctx.get("context");
@@ -1288,14 +1402,14 @@ const listAccounts = require_session.createEndpoint(listAccountsRoute, (_options
 		scopes: a.scope ? a.scope.split(",") : []
 	})), 200);
 });
-const linkAccountRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.LINK_ACCOUNT,
+const linkAccountRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.LINK_ACCOUNT,
 	method: "post",
 	path: "/link-social",
 	description: "Link a social account to the user",
 	middleware: [require_session.sessionMiddleware()],
-	request: (0, __faire_auth_core_factory.req)().bdy(linkAccountSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.REDIRECT_URL].default).err(401, "Invalid token, failed to get user info, email not found, linking not allowed, or different emails not allowed").err(404, "Provider not found").err(417, "Unable to create account").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(linkAccountSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.REDIRECT_URL].default).err(401, "Invalid token, failed to get user info, email not found, linking not allowed, or different emails not allowed").err(404, "Provider not found").err(417, "Unable to create account").zod().bld()
 });
 const linkAccount = require_session.createEndpoint(linkAccountRoute, (options) => async (ctx) => {
 	const { scopes, provider: requestedProvider, idToken } = ctx.req.valid("json");
@@ -1305,24 +1419,24 @@ const linkAccount = require_session.createEndpoint(linkAccountRoute, (options) =
 	if (!provider) {
 		context.logger.error("Provider not found. Make sure to add the provider in your auth config", { provider: requestedProvider });
 		return ctx.render({
-			success: __faire_auth_core_static.False,
-			message: __faire_auth_core_error.BASE_ERROR_CODES.PROVIDER_NOT_FOUND
+			success: _faire_auth_core_static.False,
+			message: _faire_auth_core_error.BASE_ERROR_CODES.PROVIDER_NOT_FOUND
 		}, 404);
 	}
 	if (idToken) {
 		if (!provider.verifyIdToken) {
 			context.logger.error("Provider does not support id token verification", { provider: requestedProvider });
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.ID_TOKEN_NOT_SUPPORTED
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.ID_TOKEN_NOT_SUPPORTED
 			}, 404);
 		}
 		const { token, nonce } = idToken;
 		if (!await provider.verifyIdToken(token, nonce)) {
 			context.logger.error("Invalid id token", { provider: requestedProvider });
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.INVALID_TOKEN
 			}, 401);
 		}
 		const linkingUserInfo = await provider.getUserInfo({
@@ -1333,25 +1447,25 @@ const linkAccount = require_session.createEndpoint(linkAccountRoute, (options) =
 		if (!linkingUserInfo || !linkingUserInfo?.user) {
 			context.logger.error("Failed to get user info", { provider: requestedProvider });
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_USER_INFO
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_GET_USER_INFO
 			}, 401);
 		}
 		const linkingUserId = String(linkingUserInfo.user.id);
 		if (!linkingUserInfo.user.email) {
 			context.logger.error("User email not found", { provider: requestedProvider });
 			return ctx.render({
-				success: __faire_auth_core_static.False,
-				message: __faire_auth_core_error.BASE_ERROR_CODES.USER_EMAIL_NOT_FOUND
+				success: _faire_auth_core_static.False,
+				message: _faire_auth_core_error.BASE_ERROR_CODES.USER_EMAIL_NOT_FOUND
 			}, 401);
 		}
-		if ((await context.internalAdapter.findAccounts(session.user.id)).find((a) => a.providerId === provider.id && a.accountId === linkingUserId)) return ctx.render({ redirect: __faire_auth_core_static.False }, 200);
+		if ((await context.internalAdapter.findAccounts(session.user.id)).find((a) => a.providerId === provider.id && a.accountId === linkingUserId)) return ctx.render({ redirect: _faire_auth_core_static.False }, 200);
 		if (!(options.account?.accountLinking?.trustedProviders)?.includes(provider.id) && !linkingUserInfo.user.emailVerified || options.account?.accountLinking?.enabled === false) return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Account not linked - linking not allowed"
 		}, 401);
 		if (linkingUserInfo.user.email !== session.user.email && options.account?.accountLinking?.allowDifferentEmails !== true) return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Account not linked - different emails not allowed"
 		}, 401);
 		try {
@@ -1366,7 +1480,7 @@ const linkAccount = require_session.createEndpoint(linkAccountRoute, (options) =
 			});
 		} catch (e) {
 			return ctx.render({
-				success: __faire_auth_core_static.False,
+				success: _faire_auth_core_static.False,
 				message: "Account not linked - unable to create account"
 			}, 417);
 		}
@@ -1378,7 +1492,7 @@ const linkAccount = require_session.createEndpoint(linkAccountRoute, (options) =
 		} catch (e) {
 			console.warn("Could not update user - " + e.toString());
 		}
-		return ctx.render({ redirect: __faire_auth_core_static.False }, 200);
+		return ctx.render({ redirect: _faire_auth_core_static.False }, 200);
 	}
 	const state = await require_state.generateState(ctx, {
 		userId: session.user.id,
@@ -1391,18 +1505,18 @@ const linkAccount = require_session.createEndpoint(linkAccountRoute, (options) =
 		...scopes && { scopes }
 	});
 	return ctx.render({
-		redirect: __faire_auth_core_static.True,
+		redirect: _faire_auth_core_static.True,
 		url: url.toString()
 	}, 200);
 });
-const unlinkAccountRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.UNLINK_ACCOUNT,
+const unlinkAccountRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.UNLINK_ACCOUNT,
 	method: "post",
 	path: "/unlink-account",
 	description: "Unlink an account",
 	middleware: [require_session.freshSessionMiddleware],
-	request: (0, __faire_auth_core_factory.req)().bdy(unlinkAccountSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.SUCCESS].default).err(400, "Account not found or failed to unlink").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(unlinkAccountSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.SUCCESS].default).err(400, "Account not found or failed to unlink").zod().bld()
 });
 const unlinkAccount = require_session.createEndpoint(unlinkAccountRoute, (options) => async (ctx) => {
 	const { providerId, accountId } = ctx.req.valid("json");
@@ -1410,47 +1524,47 @@ const unlinkAccount = require_session.createEndpoint(unlinkAccountRoute, (option
 	const session = ctx.get("session");
 	const accounts = await context.internalAdapter.findAccounts(session.user.id);
 	if (accounts.length === 1 && options.account?.accountLinking?.allowUnlinkingAll !== true) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_UNLINK_LAST_ACCOUNT
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.FAILED_TO_UNLINK_LAST_ACCOUNT
 	}, 400);
 	const accountExist = accounts.find((account) => accountId != null ? account.accountId === accountId && account.providerId === providerId : account.providerId === providerId);
 	if (!accountExist) return ctx.render({
-		success: __faire_auth_core_static.False,
-		message: __faire_auth_core_error.BASE_ERROR_CODES.ACCOUNT_NOT_FOUND
+		success: _faire_auth_core_static.False,
+		message: _faire_auth_core_error.BASE_ERROR_CODES.ACCOUNT_NOT_FOUND
 	}, 400);
 	await context.internalAdapter.deleteAccount(accountExist.id);
-	return ctx.render({ success: __faire_auth_core_static.True }, 200);
+	return ctx.render({ success: _faire_auth_core_static.True }, 200);
 });
-const getAccessTokenRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.GET_ACCESS_TOKEN,
+const getAccessTokenRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.GET_ACCESS_TOKEN,
 	method: "post",
 	path: "/get-access-token",
 	description: "Get a valid access token, doing a refresh if needed",
 	middleware: [require_session.requestOnlySessionMiddleware],
-	request: (0, __faire_auth_core_factory.req)().bdy(getAccessTokenSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.ACCESS_TOKEN].default, "A valid access token").err(400, "Invalid refresh token or provider configuration").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(getAccessTokenSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.ACCESS_TOKEN].default, "A valid access token").err(400, "Invalid refresh token or provider configuration").zod().bld()
 });
 const getAccessToken = require_session.createEndpoint(getAccessTokenRoute, (options) => async (ctx) => {
 	const { providerId, accountId, userId } = ctx.req.valid("json");
-	if (userId && ctx.get("isServer") !== true) return ctx.render({ success: __faire_auth_core_static.False }, 401);
+	if (userId && ctx.get("isServer") !== true) return ctx.render({ success: _faire_auth_core_static.False }, 401);
 	const resolvedUserId = ctx.get("session")?.user.id ?? userId;
 	if (resolvedUserId == null) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: `Either userId or session is required`
 	}, 400);
 	const context = ctx.get("context");
 	if (!context.socialProviders.find((p) => p.id === providerId)) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: `Provider ${providerId} is not supported.`
 	}, 400);
 	const account = (await context.internalAdapter.findAccounts(resolvedUserId)).find((acc) => accountId != null ? acc.id === accountId && acc.providerId === providerId : acc.providerId === providerId);
 	if (!account) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: "Account not found"
 	}, 400);
 	const provider = context.socialProviders.find((p) => p.id === providerId);
 	if (!provider) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: `Provider ${providerId} not found.`
 	}, 400);
 	try {
@@ -1460,17 +1574,17 @@ const getAccessToken = require_session.createEndpoint(getAccessTokenRoute, (opti
 			newTokens = await provider.refreshAccessToken(account.refreshToken);
 			await context.internalAdapter.updateAccount(account.id, {
 				...newTokens.accessToken && {
-					accessToken: await require_oauth2.setTokenUtil(newTokens.accessToken, ctx, options),
+					accessToken: await require_oauth2_index.setTokenUtil(newTokens.accessToken, ctx, options),
 					...newTokens.accessTokenExpiresAt && { accessTokenExpiresAt: newTokens.accessTokenExpiresAt }
 				},
 				...newTokens.refreshToken && {
-					refreshToken: await require_oauth2.setTokenUtil(newTokens.refreshToken, ctx, options),
+					refreshToken: await require_oauth2_index.setTokenUtil(newTokens.refreshToken, ctx, options),
 					...newTokens.refreshTokenExpiresAt && { refreshTokenExpiresAt: newTokens.refreshTokenExpiresAt }
 				}
 			});
 		}
 		const tokens = {
-			accessToken: await require_oauth2.decryptOAuthToken(newTokens?.accessToken ?? account.accessToken ?? "", ctx, options),
+			accessToken: await require_oauth2_index.decryptOAuthToken(newTokens?.accessToken ?? account.accessToken ?? "", ctx, options),
 			...newTokens?.accessTokenExpiresAt != null || account.accessTokenExpiresAt != null ? { accessTokenExpiresAt: newTokens?.accessTokenExpiresAt ?? account.accessTokenExpiresAt } : {},
 			scopes: account.scope ? account.scope.split(",") : [],
 			...(newTokens?.idToken != null && newTokens.idToken !== "" || account.idToken != null && account.idToken !== "") && { idToken: newTokens?.idToken || account.idToken }
@@ -1478,19 +1592,19 @@ const getAccessToken = require_session.createEndpoint(getAccessTokenRoute, (opti
 		return ctx.render(tokens, 200);
 	} catch {
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Failed to get a valid access token"
 		}, 400);
 	}
 });
-const refreshAccessTokenRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.REFRESH_ACCESS_TOKEN,
+const refreshAccessTokenRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.REFRESH_ACCESS_TOKEN,
 	method: "post",
 	path: "/refresh-token",
 	description: "Refresh the access token using a refresh token",
 	middleware: [require_session.sessionMiddleware()],
-	request: (0, __faire_auth_core_factory.req)().bdy(refreshAccessTokenSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.ACCESS_TOKEN].default, "Access token refreshed successfully").err(400, "Invalid refresh token or provider configuration").zod().bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(refreshAccessTokenSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.ACCESS_TOKEN].default, "Access token refreshed successfully").err(400, "Invalid refresh token or provider configuration").zod().bld()
 });
 const refreshAccessToken = require_session.createEndpoint(refreshAccessTokenRoute, (options) => async (ctx) => {
 	const context = ctx.get("context");
@@ -1498,51 +1612,51 @@ const refreshAccessToken = require_session.createEndpoint(refreshAccessTokenRout
 	const { providerId, accountId, userId } = ctx.req.valid("json");
 	const resolvedUserId = userId ?? session.user.id;
 	if (!context.socialProviders.find((p) => p.id === providerId)) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: `Provider ${providerId} is not supported.`
 	}, 400);
 	const account = (await context.internalAdapter.findAccounts(resolvedUserId)).find((acc) => accountId != null ? acc.id === accountId && acc.providerId === providerId : acc.providerId === providerId);
 	if (account?.refreshToken == null) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: "Account not found"
 	}, 400);
 	const provider = context.socialProviders.find((p) => p.id === providerId);
 	if (!provider) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: `Provider ${providerId} not found.`
 	}, 400);
 	if (!provider.refreshAccessToken) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: `Provider ${providerId} does not support token refreshing.`
 	}, 400);
 	try {
 		const tokens = await provider.refreshAccessToken(account.refreshToken);
 		await context.internalAdapter.updateAccount(account.id, {
 			...tokens.accessToken && {
-				accessToken: await require_oauth2.setTokenUtil(tokens.accessToken, ctx, options),
+				accessToken: await require_oauth2_index.setTokenUtil(tokens.accessToken, ctx, options),
 				...tokens.accessTokenExpiresAt && { accessTokenExpiresAt: tokens.accessTokenExpiresAt }
 			},
 			...tokens.refreshToken && {
-				refreshToken: await require_oauth2.setTokenUtil(tokens.refreshToken, ctx, options),
+				refreshToken: await require_oauth2_index.setTokenUtil(tokens.refreshToken, ctx, options),
 				...tokens.refreshTokenExpiresAt && { refreshTokenExpiresAt: tokens.refreshTokenExpiresAt }
 			}
 		});
 		return ctx.render(tokens, 200);
 	} catch {
 		return ctx.render({
-			success: __faire_auth_core_static.False,
+			success: _faire_auth_core_static.False,
 			message: "Failed to refresh access token"
 		}, 400);
 	}
 });
-const getAccountInfoRoute = (0, __faire_auth_core_factory.createRoute)({
-	operationId: __faire_auth_core_static.Routes.GET_ACCOUNT_INFO,
+const getAccountInfoRoute = (0, _faire_auth_core_factory.createRoute)({
+	operationId: _faire_auth_core_static.Routes.GET_ACCOUNT_INFO,
 	method: "post",
 	path: "/account-info",
 	description: "Get the account info provided by the provider",
 	middleware: [require_session.sessionMiddleware()],
-	request: (0, __faire_auth_core_factory.req)().bdy(getAccountInfoSchema).bld(),
-	responses: (0, __faire_auth_core_factory.res)(__faire_auth_core_static.SCHEMAS[__faire_auth_core_static.Definitions.ACCOUNT_INFO].default).err(400, "Account not found").zod().err(500, "Provider not configured or failed to get user info").bld()
+	request: (0, _faire_auth_core_factory.req)().bdy(getAccountInfoSchema).bld(),
+	responses: (0, _faire_auth_core_factory.res)(_faire_auth_core_static.SCHEMAS[_faire_auth_core_static.Definitions.ACCOUNT_INFO].default).err(400, "Account not found").zod().err(500, "Provider not configured or failed to get user info").bld()
 });
 const getAccountInfo = require_session.createEndpoint(getAccountInfoRoute, (_options) => async (ctx) => {
 	const { accountId } = ctx.req.valid("json");
@@ -1551,12 +1665,12 @@ const getAccountInfo = require_session.createEndpoint(getAccountInfoRoute, (_opt
 	const api = ctx.get("api");
 	const account = await context.internalAdapter.findAccount(accountId);
 	if (!account || account.userId !== session.user.id) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: "Account not found"
 	}, 400);
 	const provider = context.socialProviders.find((p) => p.id === account.providerId);
 	if (!provider) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: `Provider account provider is ${account.providerId} but it is not configured`
 	}, 500);
 	const tokensResponse = await api.getAccessToken({ json: {
@@ -1571,45 +1685,43 @@ const getAccountInfo = require_session.createEndpoint(getAccountInfoRoute, (_opt
 		...tokensResponse.data.refreshTokenExpiresAt != null && { refreshTokenExpiresAt: new Date(tokensResponse.data.refreshTokenExpiresAt) }
 	});
 	if (info == null) return ctx.render({
-		success: __faire_auth_core_static.False,
+		success: _faire_auth_core_static.False,
 		message: "Failed to get user info"
 	}, 500);
 	return ctx.render(info, 200);
 });
-
-//#endregion
-//#region src/api/endpoints.ts
+// src/api/endpoints.ts
 const staticRouteMap = {
-	[__faire_auth_core_static.Routes.SET_PASSWORD]: setPassword,
-	[__faire_auth_core_static.Routes.CHANGE_EMAIL]: changeEmail,
-	[__faire_auth_core_static.Routes.CHANGE_PASSWORD]: changePassword,
-	[__faire_auth_core_static.Routes.DELETE_USER]: deleteUser,
-	[__faire_auth_core_static.Routes.DELETE_USER_CALLBACK]: deleteUserCallback,
-	[__faire_auth_core_static.Routes.ERROR]: error,
-	[__faire_auth_core_static.Routes.GET_ACCESS_TOKEN]: getAccessToken,
-	[__faire_auth_core_static.Routes.GET_ACCOUNT_INFO]: getAccountInfo,
-	[__faire_auth_core_static.Routes.GET_SESSION]: require_session.getSession,
-	[__faire_auth_core_static.Routes.LINK_ACCOUNT]: linkAccount,
-	[__faire_auth_core_static.Routes.LIST_ACCOUNTS]: listAccounts,
-	[__faire_auth_core_static.Routes.LIST_SESSIONS]: require_session.listSessions,
-	[__faire_auth_core_static.Routes.OAUTH_CALLBACK_GET]: getOAuthCallback,
-	[__faire_auth_core_static.Routes.OAUTH_CALLBACK_POST]: postOAuthCallback,
-	[__faire_auth_core_static.Routes.OK]: ok,
-	[__faire_auth_core_static.Routes.REFRESH_ACCESS_TOKEN]: refreshAccessToken,
-	[__faire_auth_core_static.Routes.REQUEST_PASSWORD_RESET]: requestPasswordReset,
-	[__faire_auth_core_static.Routes.REQUEST_PASSWORD_RESET_CALLBACK]: requestPasswordResetCallback,
-	[__faire_auth_core_static.Routes.RESET_PASSWORD]: resetPassword,
-	[__faire_auth_core_static.Routes.REVOKE_OTHER_SESSIONS]: require_session.revokeOtherSessions,
-	[__faire_auth_core_static.Routes.REVOKE_SESSION]: require_session.revokeSession,
-	[__faire_auth_core_static.Routes.REVOKE_SESSIONS]: require_session.revokeSessions,
-	[__faire_auth_core_static.Routes.SEND_VERIFICATION_EMAIL]: require_email_verification.sendVerificationEmail,
-	[__faire_auth_core_static.Routes.SIGN_IN_EMAIL]: signInEmail,
-	[__faire_auth_core_static.Routes.SIGN_IN_SOCIAL]: signInSocial,
-	[__faire_auth_core_static.Routes.SIGN_OUT]: signOut,
-	[__faire_auth_core_static.Routes.SIGN_UP_EMAIL]: signUpEmail,
-	[__faire_auth_core_static.Routes.UNLINK_ACCOUNT]: unlinkAccount,
-	[__faire_auth_core_static.Routes.UPDATE_USER]: updateUser,
-	[__faire_auth_core_static.Routes.VERIFY_EMAIL]: require_email_verification.verifyEmail
+	[_faire_auth_core_static.Routes.SET_PASSWORD]: setPassword,
+	[_faire_auth_core_static.Routes.CHANGE_EMAIL]: changeEmail,
+	[_faire_auth_core_static.Routes.CHANGE_PASSWORD]: changePassword,
+	[_faire_auth_core_static.Routes.DELETE_USER]: deleteUser,
+	[_faire_auth_core_static.Routes.DELETE_USER_CALLBACK]: deleteUserCallback,
+	[_faire_auth_core_static.Routes.ERROR]: error,
+	[_faire_auth_core_static.Routes.GET_ACCESS_TOKEN]: getAccessToken,
+	[_faire_auth_core_static.Routes.GET_ACCOUNT_INFO]: getAccountInfo,
+	[_faire_auth_core_static.Routes.GET_SESSION]: require_session.getSession,
+	[_faire_auth_core_static.Routes.LINK_ACCOUNT]: linkAccount,
+	[_faire_auth_core_static.Routes.LIST_ACCOUNTS]: listAccounts,
+	[_faire_auth_core_static.Routes.LIST_SESSIONS]: require_session.listSessions,
+	[_faire_auth_core_static.Routes.OAUTH_CALLBACK_GET]: getOAuthCallback,
+	[_faire_auth_core_static.Routes.OAUTH_CALLBACK_POST]: postOAuthCallback,
+	[_faire_auth_core_static.Routes.OK]: ok,
+	[_faire_auth_core_static.Routes.REFRESH_ACCESS_TOKEN]: refreshAccessToken,
+	[_faire_auth_core_static.Routes.REQUEST_PASSWORD_RESET]: requestPasswordReset,
+	[_faire_auth_core_static.Routes.REQUEST_PASSWORD_RESET_CALLBACK]: requestPasswordResetCallback,
+	[_faire_auth_core_static.Routes.RESET_PASSWORD]: resetPassword,
+	[_faire_auth_core_static.Routes.REVOKE_OTHER_SESSIONS]: require_session.revokeOtherSessions,
+	[_faire_auth_core_static.Routes.REVOKE_SESSION]: require_session.revokeSession,
+	[_faire_auth_core_static.Routes.REVOKE_SESSIONS]: require_session.revokeSessions,
+	[_faire_auth_core_static.Routes.SEND_VERIFICATION_EMAIL]: require_email_verification.sendVerificationEmail,
+	[_faire_auth_core_static.Routes.SIGN_IN_EMAIL]: signInEmail,
+	[_faire_auth_core_static.Routes.SIGN_IN_SOCIAL]: signInSocial,
+	[_faire_auth_core_static.Routes.SIGN_OUT]: signOut,
+	[_faire_auth_core_static.Routes.SIGN_UP_EMAIL]: signUpEmail,
+	[_faire_auth_core_static.Routes.UNLINK_ACCOUNT]: unlinkAccount,
+	[_faire_auth_core_static.Routes.UPDATE_USER]: updateUser,
+	[_faire_auth_core_static.Routes.VERIFY_EMAIL]: require_email_verification.verifyEmail
 };
 const resolveHooks = (options) => {
 	const routeHooks = { ...options.routeHooks };
@@ -1644,16 +1756,14 @@ const createArgs = (endpoints, builtSchemas, context, routeHooks) => {
 	}
 	return groups;
 };
-
-//#endregion
-//#region src/api/middleware/intercept.ts
+// src/api/middleware/intercept.ts
 const runIntercept = (ctx, hooks) => {
 	let response = void 0;
 	for (const hook of hooks) try {
 		const result = hook(ctx);
 		if (result instanceof Response) response = result;
-	} catch (error$1) {
-		ctx.error = error$1;
+	} catch (error) {
+		ctx.error = error;
 	}
 	return response;
 };
@@ -1685,9 +1795,7 @@ const initInterceptMiddleware = (options) => {
 		if (after instanceof Response) ctx.res = after;
 	});
 };
-
-//#endregion
-//#region src/api/middleware/on-disabled.ts
+// src/api/middleware/on-disabled.ts
 /**
 * Initializes the middleware to handle disabled paths.
 * @param options - The FaireAuth options.
@@ -1701,9 +1809,7 @@ const initHandleDisabledMiddleware = (options) => {
 		return await next();
 	});
 };
-
-//#endregion
-//#region src/api/middleware/rate-limit.ts
+// src/api/middleware/rate-limit.ts
 const shouldRateLimit = (max, window, rateLimitData) => {
 	const now = Date.now();
 	const windowInMs = window * 1e3;
@@ -1712,7 +1818,7 @@ const shouldRateLimit = (max, window, rateLimitData) => {
 const rateLimitResponse = (ctx, retryAfter) => {
 	ctx.header("X-Retry-After", retryAfter.toString());
 	return ctx.json({
-		status: __faire_auth_core_static.False,
+		status: _faire_auth_core_static.False,
 		message: "Too many requests. Please try again later."
 	}, 429);
 };
@@ -1726,21 +1832,21 @@ const createDBStorage = (ctx) => {
 	const db = ctx.adapter;
 	return {
 		get: async (key) => {
-			const res$9 = db.findMany({
+			const res = db.findMany({
 				model,
 				where: [{
 					field: "key",
 					value: key
 				}]
 			});
-			const data = (0, __faire_auth_core_static.isPromise)(res$9) ? (await res$9)[0] : res$9[0];
+			const data = (0, _faire_auth_core_static.isPromise)(res) ? (await res)[0] : res[0];
 			if (typeof data?.lastRequest === "bigint") data.lastRequest = Number(data.lastRequest);
 			return data;
 		},
 		set: async (key, value, _update) => {
 			try {
 				if (_update === true) {
-					const res$9 = db.updateMany({
+					const res = db.updateMany({
 						model: "rateLimit",
 						where: [{
 							field: "key",
@@ -1751,9 +1857,9 @@ const createDBStorage = (ctx) => {
 							lastRequest: value.lastRequest
 						}
 					});
-					if ((0, __faire_auth_core_static.isPromise)(res$9)) await res$9;
+					if ((0, _faire_auth_core_static.isPromise)(res)) await res;
 				} else {
-					const res$9 = await db.create({
+					const res = await db.create({
 						model: "rateLimit",
 						data: {
 							key,
@@ -1761,7 +1867,7 @@ const createDBStorage = (ctx) => {
 							lastRequest: value.lastRequest
 						}
 					});
-					if ((0, __faire_auth_core_static.isPromise)(res$9)) await res$9;
+					if ((0, _faire_auth_core_static.isPromise)(res)) await res;
 				}
 			} catch (e) {
 				ctx.logger.error("Error setting rate limit", e);
@@ -1780,8 +1886,8 @@ const getRateLimitStorage = (config, context, options) => {
 	if (options.rateLimit?.customStorage) return options.rateLimit.customStorage;
 	if (config.storage === "secondary-storage") return {
 		get: (key) => {
-			const res$9 = options.secondaryStorage?.get(key);
-			return (0, __faire_auth_core_static.isPromise)(res$9) ? res$9.then((r) => r ? require_json.safeJSONParse(r) : void 0) : res$9 ? require_json.safeJSONParse(res$9) : void 0;
+			const res = options.secondaryStorage?.get(key);
+			return (0, _faire_auth_core_static.isPromise)(res) ? res.then((r) => r ? require_json.safeJSONParse(r) : void 0) : res ? require_json.safeJSONParse(res) : void 0;
 		},
 		set: (key, value) => options.secondaryStorage?.set(key, JSON.stringify(value))
 	};
@@ -1829,8 +1935,8 @@ const initRateLimitMiddleware = (options, rateLimit) => {
 			const _path = Object.keys(rateLimit.customRules).find((p) => p.includes("*") ? require_origin_check.wildcardMatch(p)(path) : p === path);
 			if (_path) {
 				const customRule = rateLimit.customRules[_path];
-				const res$10 = typeof customRule === "function" ? customRule(ctx.req) : customRule;
-				const resolved = (0, __faire_auth_core_static.isPromise)(res$10) ? await res$10 : res$10;
+				const res = typeof customRule === "function" ? customRule(ctx.req) : customRule;
+				const resolved = (0, _faire_auth_core_static.isPromise)(res) ? await res : res;
 				if (resolved) {
 					window = resolved.window;
 					max = resolved.max;
@@ -1839,47 +1945,48 @@ const initRateLimitMiddleware = (options, rateLimit) => {
 			}
 		}
 		const storage = getRateLimitStorage(rateLimit, context, options);
-		const res$9 = storage.get(key);
+		const res = storage.get(key);
 		const now = Date.now();
-		const data = (0, __faire_auth_core_static.isPromise)(res$9) ? await res$9 : res$9;
+		const data = (0, _faire_auth_core_static.isPromise)(res) ? await res : res;
 		if (!data) {
 			const res2 = storage.set(key, {
 				key,
 				count: 1,
 				lastRequest: now
 			});
-			if ((0, __faire_auth_core_static.isPromise)(res2)) await res2;
+			if ((0, _faire_auth_core_static.isPromise)(res2)) await res2;
 		} else {
 			const timeSinceLastRequest = now - data.lastRequest;
-			if (shouldRateLimit(max, window, data)) return rateLimitResponse(ctx, getRetryAfter(data.lastRequest, window));
+			if (shouldRateLimit(max, window, data)) {
+				const retryAfter = getRetryAfter(data.lastRequest, window);
+				return rateLimitResponse(ctx, retryAfter);
+			}
 			if (timeSinceLastRequest > window * 1e3) {
 				const res3 = storage.set(key, {
 					...data,
 					count: 1,
 					lastRequest: now
 				}, true);
-				if ((0, __faire_auth_core_static.isPromise)(res3)) await res3;
+				if ((0, _faire_auth_core_static.isPromise)(res3)) await res3;
 			} else {
 				const res3 = storage.set(key, {
 					...data,
 					count: data.count + 1,
 					lastRequest: now
 				}, true);
-				if ((0, __faire_auth_core_static.isPromise)(res3)) await res3;
+				if ((0, _faire_auth_core_static.isPromise)(res3)) await res3;
 			}
 		}
 		return await next();
 	});
 };
-
-//#endregion
-//#region src/api/index.ts
+// src/api/index.ts
 const router = (context, options) => {
-	const schemas = (0, __faire_auth_core_utils.buildSchemas)(__faire_auth_core_static.SCHEMAS, options);
+	const schemas = (0, _faire_auth_core_utils.buildSchemas)(_faire_auth_core_static.SCHEMAS, options);
 	const { endpoints, hooks } = createEndpoints(options);
 	const { pub } = createArgs(endpoints, schemas, context, hooks);
 	const api = require_session.createAPI(endpoints);
-	let app = new __faire_auth_core_factory.OpenAPIHono(options).openapi(...pub[0]).openapi(...pub[1]).openapi(...pub[2]).openapi(...pub[3]).openapi(...pub[4]).openapi(...pub[5]).openapi(...pub[6]).openapi(...pub[7]).openapi(...pub[8]).openapi(...pub[9]).openapi(...pub[10]).openapi(...pub[11]).openapi(...pub[12]).openapi(...pub[13]).openapi(...pub[14]).openapi(...pub[15]).openapi(...pub[16]).openapi(...pub[17]).openapi(...pub[18]).openapi(...pub[19]).openapi(...pub[20]).openapi(...pub[21]).openapi(...pub[22]).openapi(...pub[23]).openapi(...pub[24]).openapi(...pub[25]).openapi(...pub[26]).openapi(...pub[27]).openapi(...pub[28]);
+	let app = new _faire_auth_core_factory.OpenAPIHono(options).openapi(...pub[0]).openapi(...pub[1]).openapi(...pub[2]).openapi(...pub[3]).openapi(...pub[4]).openapi(...pub[5]).openapi(...pub[6]).openapi(...pub[7]).openapi(...pub[8]).openapi(...pub[9]).openapi(...pub[10]).openapi(...pub[11]).openapi(...pub[12]).openapi(...pub[13]).openapi(...pub[14]).openapi(...pub[15]).openapi(...pub[16]).openapi(...pub[17]).openapi(...pub[18]).openapi(...pub[19]).openapi(...pub[20]).openapi(...pub[21]).openapi(...pub[22]).openapi(...pub[23]).openapi(...pub[24]).openapi(...pub[25]).openapi(...pub[26]).openapi(...pub[27]).openapi(...pub[28]);
 	pub.slice(29).forEach((route) => app = app.openapi(...route));
 	return {
 		api,
@@ -1889,11 +1996,9 @@ const router = (context, options) => {
 		}).basePath(options.basePath).use(require_session.setDefaultExecutionCtx, require_session.setRenderer, require_session.initContextMiddleware(options, context, endpoints), (0, hono_context_storage.contextStorage)(), initHandleDisabledMiddleware(options), initInterceptMiddleware(options), initRateLimitMiddleware(options, context.rateLimit), require_origin_check.initOriginCheckMiddleware(options, context), require_session.initHooksMiddleware(options)).onError(require_session.initErrorHandler(options)).route("/", app)
 	};
 };
-
-//#endregion
-Object.defineProperty(exports, 'router', {
-  enumerable: true,
-  get: function () {
-    return router;
-  }
-});
+Object.defineProperty(exports, "router", {
+	enumerable: true,
+	get: function() {
+		return router;
+	}
+});