@rio.js/enterprise 1.4.0

package/dist/better-auth-CStoaWiq.d.mts

@@ -0,0 +1,10 @@
+import * as better_auth0 from "better-auth";
+import { BetterAuthPlugin, betterAuth } from "better-auth";
+
+//#region src/better-auth.d.ts
+declare function createAuthSystem(options: {
+  plugins?: BetterAuthPlugin[];
+}): ReturnType<typeof betterAuth>;
+declare const auth: better_auth0.Auth<better_auth0.BetterAuthOptions>;
+//#endregion
+export { createAuthSystem as n, auth as t };

package/dist/better-auth-CqfhQJYE.mjs

@@ -0,0 +1,558 @@
+import { n as db } from "./db-BVXTgOd3.mjs";
+import { G as getCurrentTransactionAdapter, W as getCurrentGraphContext } from "./json-oFuWgANh-O1U6k3bL.mjs";
+import { f as logger, g as BetterAuthError, v as invariant } from "./env-DwlNAN_D-C1zHd0cf-Cdlw8sNp.mjs";
+import { A as apiKey, E as admin, K as graph, R as lastLoginMethod, U as organization, a as openAPI, it as APIError$1, j as assets, k as agents, rt as twoFactor, z as mcp } from "./plugins-BNFht2HW.mjs";
+import { n as betterAuth, t as db_schema_final_exports } from "./db-schema.final-DWleoQm0.mjs";
+import { t as createAdapterFactory } from "./adapter-factory-BTRALCLD-kJBwe70v.mjs";
+import { and, asc, count, desc, eq, gt, gte, inArray, like, lt, lte, ne, notInArray, or, sql } from "drizzle-orm";
+import cuid from "cuid";
+
+//#region ../better-auth/dist/adapters/drizzle-adapter/index.mjs
+const drizzleAdapter = (db$1, config) => {
+	let lazyOptions = null;
+	const createCustomAdapter = (db$1$1) => ({ getFieldName, options }) => {
+		function getSchema(model) {
+			const schema = config.schema || db$1$1._.fullSchema;
+			if (!schema) throw new BetterAuthError("Drizzle adapter failed to initialize. Schema not found. Please provide a schema object in the adapter options object.");
+			const schemaModel = schema[model];
+			if (!schemaModel) throw new BetterAuthError(`[# Drizzle Adapter]: The model "${model}" was not found in the schema object. Please pass the schema directly to the adapter options.`);
+			return schemaModel;
+		}
+		const withReturning = async (model, builder, data, where) => {
+			if (config.provider !== "mysql") return (await builder.returning())[0];
+			await builder.execute();
+			const schemaModel = getSchema(model);
+			const builderVal = builder.config?.values;
+			if (where?.length) {
+				const clause = convertWhereClause(where.map((w) => {
+					if (data[w.field] !== void 0) return {
+						...w,
+						value: data[w.field]
+					};
+					return w;
+				}), model);
+				return (await db$1$1.select().from(schemaModel).where(...clause))[0];
+			} else if (builderVal && builderVal[0]?.id?.value) {
+				let tId = builderVal[0]?.id?.value;
+				if (!tId) tId = (await db$1$1.select({ id: sql`LAST_INSERT_ID()` }).from(schemaModel).orderBy(desc(schemaModel.id)).limit(1))[0].id;
+				return (await db$1$1.select().from(schemaModel).where(eq(schemaModel.id, tId)).limit(1).execute())[0];
+			} else if (data.id) return (await db$1$1.select().from(schemaModel).where(eq(schemaModel.id, data.id)).limit(1).execute())[0];
+			else {
+				if (!("id" in schemaModel)) throw new BetterAuthError(`The model "${model}" does not have an "id" field. Please use the "id" field as your primary key.`);
+				return (await db$1$1.select().from(schemaModel).orderBy(desc(schemaModel.id)).limit(1).execute())[0];
+			}
+		};
+		function convertWhereClause(where, model) {
+			const schemaModel = getSchema(model);
+			if (!where) return [];
+			if (where.length === 1) {
+				const w = where[0];
+				if (!w) return [];
+				const field = getFieldName({
+					model,
+					field: w.field
+				});
+				if (!schemaModel[field]) throw new BetterAuthError(`The field "${w.field}" does not exist in the schema for the model "${model}". Please update your schema.`);
+				if (w.operator === "in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "in" operator.`);
+					return [inArray(schemaModel[field], w.value)];
+				}
+				if (w.operator === "not_in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "not_in" operator.`);
+					return [notInArray(schemaModel[field], w.value)];
+				}
+				if (w.operator === "contains") return [like(schemaModel[field], `%${w.value}%`)];
+				if (w.operator === "starts_with") return [like(schemaModel[field], `${w.value}%`)];
+				if (w.operator === "ends_with") return [like(schemaModel[field], `%${w.value}`)];
+				if (w.operator === "lt") return [lt(schemaModel[field], w.value)];
+				if (w.operator === "lte") return [lte(schemaModel[field], w.value)];
+				if (w.operator === "ne") return [ne(schemaModel[field], w.value)];
+				if (w.operator === "gt") return [gt(schemaModel[field], w.value)];
+				if (w.operator === "gte") return [gte(schemaModel[field], w.value)];
+				return [eq(schemaModel[field], w.value)];
+			}
+			const andGroup = where.filter((w) => w.connector === "AND" || !w.connector);
+			const orGroup = where.filter((w) => w.connector === "OR");
+			const andClause = and(...andGroup.map((w) => {
+				const field = getFieldName({
+					model,
+					field: w.field
+				});
+				if (w.operator === "in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "in" operator.`);
+					return inArray(schemaModel[field], w.value);
+				}
+				if (w.operator === "not_in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "not_in" operator.`);
+					return notInArray(schemaModel[field], w.value);
+				}
+				if (w.operator === "contains") return like(schemaModel[field], `%${w.value}%`);
+				if (w.operator === "starts_with") return like(schemaModel[field], `${w.value}%`);
+				if (w.operator === "ends_with") return like(schemaModel[field], `%${w.value}`);
+				if (w.operator === "lt") return lt(schemaModel[field], w.value);
+				if (w.operator === "lte") return lte(schemaModel[field], w.value);
+				if (w.operator === "gt") return gt(schemaModel[field], w.value);
+				if (w.operator === "gte") return gte(schemaModel[field], w.value);
+				if (w.operator === "ne") return ne(schemaModel[field], w.value);
+				return eq(schemaModel[field], w.value);
+			}));
+			const orClause = or(...orGroup.map((w) => {
+				const field = getFieldName({
+					model,
+					field: w.field
+				});
+				if (w.operator === "in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "in" operator.`);
+					return inArray(schemaModel[field], w.value);
+				}
+				if (w.operator === "not_in") {
+					if (!Array.isArray(w.value)) throw new BetterAuthError(`The value for the field "${w.field}" must be an array when using the "not_in" operator.`);
+					return notInArray(schemaModel[field], w.value);
+				}
+				if (w.operator === "contains") return like(schemaModel[field], `%${w.value}%`);
+				if (w.operator === "starts_with") return like(schemaModel[field], `${w.value}%`);
+				if (w.operator === "ends_with") return like(schemaModel[field], `%${w.value}`);
+				if (w.operator === "lt") return lt(schemaModel[field], w.value);
+				if (w.operator === "lte") return lte(schemaModel[field], w.value);
+				if (w.operator === "gt") return gt(schemaModel[field], w.value);
+				if (w.operator === "gte") return gte(schemaModel[field], w.value);
+				if (w.operator === "ne") return ne(schemaModel[field], w.value);
+				return eq(schemaModel[field], w.value);
+			}));
+			const clause = [];
+			if (andGroup.length) clause.push(andClause);
+			if (orGroup.length) clause.push(orClause);
+			return clause;
+		}
+		function checkMissingFields(schema, model, values) {
+			if (!schema) throw new BetterAuthError("Drizzle adapter failed to initialize. Drizzle Schema not found. Please provide a schema object in the adapter options object.");
+			for (const key in values) if (!schema[key]) throw new BetterAuthError(`The field "${key}" does not exist in the "${model}" Drizzle schema. Please update your drizzle schema or re-generate using "npx @better-auth/cli@latest generate".`);
+		}
+		return {
+			async create({ model, data: values }) {
+				const schemaModel = getSchema(model);
+				checkMissingFields(schemaModel, model, values);
+				return await withReturning(model, db$1$1.insert(schemaModel).values(values), values);
+			},
+			async createMany({ model, data: rows }) {
+				const schemaModel = getSchema(model);
+				rows.forEach((row) => {
+					checkMissingFields(schemaModel, model, row);
+				});
+				await db$1$1.insert(schemaModel).values(rows).execute();
+				return rows;
+			},
+			async findOne({ model, where, join }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				if (options.experimental?.joins) if (!db$1$1.query || !db$1$1.query[model]) {
+					logger.error(`[# Drizzle Adapter]: The model "${model}" was not found in the query object. Please update your Drizzle schema to include relations or re-generate using "npx @better-auth/cli@latest generate".`);
+					logger.info("Falling back to regular query");
+				} else {
+					let includes;
+					const pluralJoinResults = [];
+					if (join) {
+						includes = {};
+						const joinEntries = Object.entries(join);
+						for (const [model$1, joinAttr] of joinEntries) {
+							const limit = joinAttr.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+							const isUnique = joinAttr.relation === "one-to-one";
+							const pluralSuffix = isUnique || config.usePlural ? "" : "s";
+							includes[`${model$1}${pluralSuffix}`] = isUnique ? true : { limit };
+							if (!isUnique) pluralJoinResults.push(`${model$1}${pluralSuffix}`);
+						}
+					}
+					const res$1 = await db$1$1.query[model].findFirst({
+						where: clause[0],
+						with: includes
+					});
+					if (res$1) for (const pluralJoinResult of pluralJoinResults) {
+						let singularKey = !config.usePlural ? pluralJoinResult.slice(0, -1) : pluralJoinResult;
+						res$1[singularKey] = res$1[pluralJoinResult];
+						if (pluralJoinResult !== singularKey) delete res$1[pluralJoinResult];
+					}
+					return res$1;
+				}
+				const res = await db$1$1.select().from(schemaModel).where(...clause);
+				if (!res.length) return null;
+				return res[0];
+			},
+			async findMany({ model, where, sortBy, limit, offset, join }) {
+				const schemaModel = getSchema(model);
+				const clause = where ? convertWhereClause(where, model) : [];
+				const sortFn = sortBy?.direction === "desc" ? desc : asc;
+				if (options.experimental?.joins) if (!db$1$1.query[model]) {
+					logger.error(`[# Drizzle Adapter]: The model "${model}" was not found in the query object. Please update your Drizzle schema to include relations or re-generate using "npx @better-auth/cli@latest generate".`);
+					logger.info("Falling back to regular query");
+				} else {
+					let includes;
+					const pluralJoinResults = [];
+					if (join) {
+						includes = {};
+						const joinEntries = Object.entries(join);
+						for (const [model$1, joinAttr] of joinEntries) {
+							const isUnique = joinAttr.relation === "one-to-one";
+							const limit$1 = joinAttr.limit ?? options.advanced?.database?.defaultFindManyLimit ?? 100;
+							let pluralSuffix = isUnique || config.usePlural ? "" : "s";
+							includes[`${model$1}${pluralSuffix}`] = isUnique ? true : { limit: limit$1 };
+							if (!isUnique) pluralJoinResults.push(`${model$1}${pluralSuffix}`);
+						}
+					}
+					let orderBy = void 0;
+					if (sortBy?.field) orderBy = [sortFn(schemaModel[getFieldName({
+						model,
+						field: sortBy?.field
+					})])];
+					let res = await db$1$1.query[model].findMany({
+						where: clause[0],
+						with: includes,
+						limit: limit ?? 100,
+						offset: offset ?? 0,
+						orderBy
+					});
+					if (res) for (const item of res) for (const pluralJoinResult of pluralJoinResults) {
+						const singularKey = !config.usePlural ? pluralJoinResult.slice(0, -1) : pluralJoinResult;
+						if (singularKey === pluralJoinResult) continue;
+						item[singularKey] = item[pluralJoinResult];
+						delete item[pluralJoinResult];
+					}
+					return res;
+				}
+				let builder = db$1$1.select().from(schemaModel);
+				const effectiveLimit = limit;
+				const effectiveOffset = offset;
+				if (typeof effectiveLimit !== "undefined") builder = builder.limit(effectiveLimit);
+				if (typeof effectiveOffset !== "undefined") builder = builder.offset(effectiveOffset);
+				if (sortBy?.field) builder = builder.orderBy(sortFn(schemaModel[getFieldName({
+					model,
+					field: sortBy?.field
+				})]));
+				return await builder.where(...clause);
+			},
+			async count({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = where ? convertWhereClause(where, model) : [];
+				return (await db$1$1.select({ count: count() }).from(schemaModel).where(...clause))[0].count;
+			},
+			async update({ model, where, update: values }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return await withReturning(model, db$1$1.update(schemaModel).set(values).where(...clause), values, where);
+			},
+			async updateMany({ model, where, update: values }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return await db$1$1.update(schemaModel).set(values).where(...clause);
+			},
+			async delete({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				return await db$1$1.delete(schemaModel).where(...clause);
+			},
+			async deleteMany({ model, where }) {
+				const schemaModel = getSchema(model);
+				const clause = convertWhereClause(where, model);
+				const res = await db$1$1.delete(schemaModel).where(...clause);
+				let count$1 = 0;
+				if (res && "rowCount" in res) count$1 = res.rowCount;
+				else if (Array.isArray(res)) count$1 = res.length;
+				else if (res && ("affectedRows" in res || "rowsAffected" in res || "changes" in res)) count$1 = res.affectedRows ?? res.rowsAffected ?? res.changes;
+				if (typeof count$1 !== "number") logger.error("[Drizzle Adapter] The result of the deleteMany operation is not a number. This is likely a bug in the adapter. Please report this issue to the Better Auth team.", {
+					res,
+					model,
+					where
+				});
+				return count$1;
+			},
+			options: config
+		};
+	};
+	let adapterOptions = null;
+	adapterOptions = {
+		config: {
+			adapterId: "drizzle",
+			adapterName: "Drizzle Adapter",
+			usePlural: config.usePlural ?? false,
+			debugLogs: config.debugLogs ?? false,
+			supportsUUIDs: config.provider === "pg" ? true : false,
+			transaction: config.transaction ?? false ? (cb) => db$1.transaction((tx) => {
+				return cb(createAdapterFactory({
+					config: {
+						...adapterOptions.config,
+						adapterName: "Drizzle Adapter (Transaction)",
+						adapterId: "drizzle-transaction"
+					},
+					adapter: createCustomAdapter(tx)
+				})(lazyOptions));
+			}) : false
+		},
+		adapter: createCustomAdapter(db$1)
+	};
+	const adapter = createAdapterFactory(adapterOptions);
+	return (options) => {
+		lazyOptions = options;
+		return adapter(options);
+	};
+};
+
+//#endregion
+//#region src/utils/email.ts
+/**
+* Sends an email using the configured email service.
+* Currently supports Resend. Falls back to console logging in development.
+*/
+async function sendEmail(options) {
+	const { to, subject, text, html, from } = options;
+	const resendApiKey = process.env.RESEND_API_KEY;
+	if (resendApiKey) try {
+		const { Resend } = await import("resend");
+		await new Resend(resendApiKey).emails.send({
+			from: from || process.env.EMAIL_FROM || "onboarding@resend.dev",
+			to,
+			subject,
+			text,
+			html,
+			react: void 0
+		});
+		return;
+	} catch (error) {
+		if (error.message?.includes("Cannot find module")) console.warn("Resend package not found. Install it with: npm install resend");
+		else throw error;
+	}
+	if (process.env.NODE_ENV !== "production") {
+		console.log("=".repeat(50));
+		console.log("📧 Email would be sent:");
+		console.log(`To: ${to}`);
+		console.log(`Subject: ${subject}`);
+		console.log(`From: ${from || process.env.EMAIL_FROM || "noreply@example.com"}`);
+		if (text) console.log(`Text:\n${text}`);
+		if (html) console.log(`HTML:\n${html}`);
+		console.log("=".repeat(50));
+		return;
+	}
+	throw new Error("Email service not configured. Set RESEND_API_KEY environment variable or configure another email service.");
+}
+
+//#endregion
+//#region src/better-auth.ts
+const tablePrefixes = {
+	user: "usr",
+	organization: "org",
+	member: "mem",
+	human: "hmn",
+	agent: "agt",
+	session: "ses",
+	account: "acc",
+	api_key: "key",
+	subscription: "sub",
+	relationship: "rel",
+	team: "tm"
+};
+function generatePrefixedId(model) {
+	return `${tablePrefixes[model] ?? model}_${cuid()}`;
+}
+/**
+* Get or create a personal organization for a user
+* Personal organizations are named after the user and have a slug based on their user ID
+*/
+async function getOrCreatePersonalOrganization(userId, userName) {
+	const adapter = await getCurrentTransactionAdapter();
+	const graphAdapter = await getCurrentGraphContext();
+	const existingMembers = await adapter.findMany({
+		model: "member",
+		where: [{
+			field: "userId",
+			value: userId
+		}]
+	});
+	for (const member of existingMembers) if (await adapter.findOne({
+		model: "organization",
+		where: [{
+			field: "id",
+			value: member.organizationId
+		}, {
+			field: "slug",
+			value: `user-${userId}`
+		}]
+	})) return null;
+	generatePrefixedId("organization");
+	const orgSlug = `user-${userId}`;
+	const orgName = `${userName}'s Personal Organization`;
+	const org = await adapter.create({
+		model: "organization",
+		data: {
+			name: orgName,
+			slug: orgSlug,
+			metadata: {
+				type: "personal",
+				userId
+			},
+			createdAt: /* @__PURE__ */ new Date()
+		}
+	});
+	if (!org) throw new Error("Failed to create personal organization");
+	let adminRoleId = `role_admin_${org.id}`;
+	await adapter.create({
+		model: "member",
+		data: {
+			organizationId: org.id,
+			userId,
+			createdAt: /* @__PURE__ */ new Date()
+		}
+	});
+	graphAdapter.addRelationship({
+		subjectId: org.id,
+		subjectType: "organization",
+		relationshipType: "organization",
+		objectId: adminRoleId,
+		objectType: "organization_role"
+	});
+	graphAdapter.addRelationship({
+		subjectId: adminRoleId,
+		subjectType: "organization_role",
+		relationshipType: "roles",
+		objectId: org.id,
+		objectType: "organization"
+	});
+	graphAdapter.addRelationship({
+		subjectId: org.id,
+		subjectType: "organization",
+		relationshipType: "built_in_role",
+		objectId: adminRoleId,
+		objectType: "organization_role"
+	});
+	graphAdapter.addRelationship({
+		subjectId: adminRoleId,
+		subjectType: "organization_role",
+		objectId: org.id,
+		objectType: "organization",
+		relationshipType: "org_manager",
+		optionalRelation: "member"
+	});
+	graphAdapter.addRelationship({
+		subjectId: userId,
+		subjectType: "user",
+		relationshipType: "has_role",
+		objectId: adminRoleId,
+		objectType: "organization_role"
+	});
+	return org;
+}
+function createAuthSystem(options) {
+	return betterAuth({
+		plugins: [
+			admin({ adminUserIds: ["user_cmhz0nka100003xv322cn6ffp"] }),
+			apiKey(),
+			organization({
+				teams: { enabled: true },
+				schema: {},
+				sendInvitationEmail(data, request) {
+					const url = new URL(`/auth/accept-invitation?invitationId=${data.invitation.id}`, request?.url).href;
+					return sendEmail({
+						to: data.invitation.email,
+						subject: "You are invited to join an organization",
+						text: `Click the link to accept the invitation: ${url}`
+					});
+				},
+				organizationHooks: {
+					beforeCreateOrganization: async (data) => {
+						if (!await (await getCurrentGraphContext()).check("user", data.user.id, "create_org", "platform", "default")) throw new APIError$1("UNAUTHORIZED", { message: "You are not authorized to create an organization" });
+					},
+					afterCreateOrganization: async (data) => {},
+					async beforeUpdateOrganization(data) {
+						if (!await (await getCurrentGraphContext()).check("user", data.user.id, "manage", "organization", data.organization.id)) throw new APIError$1("UNAUTHORIZED", { message: "You are not authorized to manage this organization" });
+					}
+				}
+			}),
+			mcp({ loginPage: "/sign-in" }),
+			twoFactor(),
+			agents(),
+			assets(),
+			graph({
+				authzed: process.env.AUTHZED_TOKEN ? {
+					token: process.env.AUTHZED_TOKEN,
+					endpoint: process.env.AUTHZED_ENDPOINT
+				} : void 0,
+				autoSync: process.env.AUTHZED_AUTO_SYNC !== "false"
+			}),
+			lastLoginMethod(),
+			openAPI(),
+			...options.plugins ?? []
+		],
+		account: { accountLinking: { enabled: true } },
+		trustedOrigins: ["http://localhost:3000"],
+		emailAndPassword: {
+			enabled: true,
+			requireEmailVerification: true,
+			sendResetPassword: async ({ user, url, token }, request) => {
+				await sendEmail({
+					to: user.email,
+					subject: "Reset your password",
+					text: `Click the link to reset your password: ${url}`
+				});
+			}
+		},
+		hooks: {},
+		databaseHooks: { user: { create: {
+			async before(user, options$1) {
+				if (user.actorType === "agent") {} else {
+					invariant(!!options$1?.context.adapter, "Adapter is required");
+					if (!user.id) user.id = generatePrefixedId("user");
+					const adapter = await getCurrentTransactionAdapter();
+					const graphAdapter = await getCurrentGraphContext();
+					const person = await adapter.create({
+						model: "person",
+						data: { name: user.name },
+						select: ["id"]
+					});
+					await graphAdapter.addRelationship({
+						subjectId: person.id,
+						subjectType: "person",
+						objectId: user.id,
+						objectType: "user",
+						relationshipType: "person_profile"
+					});
+					if (!person) throw new Error("Failed to create person");
+					user.actorType = "person";
+					user.actorId = person.id;
+				}
+				return { data: user };
+			},
+			async after(user, context) {
+				if (user.actorType === "person" && user.id) await getOrCreatePersonalOrganization(user.id, user.name || "User");
+			}
+		} } },
+		user: { additionalFields: {
+			actorType: {
+				type: "string",
+				defaultValue: "person"
+			},
+			actorId: { type: "string" }
+		} },
+		advanced: { database: { generateId: (options$1) => {
+			return generatePrefixedId(options$1.model);
+		} } },
+		emailVerification: {
+			sendOnSignUp: true,
+			async sendVerificationEmail(data, request) {
+				await sendEmail({
+					to: data.user.email,
+					subject: "Verify your email",
+					text: `Click the link to verify your email: ${data.url}`
+				});
+			}
+		},
+		database: drizzleAdapter(db, {
+			provider: "pg",
+			schema: db_schema_final_exports,
+			usePlural: false,
+			transaction: true
+		}),
+		experimental: { joins: true },
+		graph: { enabled: true }
+	});
+}
+const auth = createAuthSystem({});
+
+//#endregion
+export { createAuthSystem as n, auth as t };

package/dist/better-auth.d.mts

@@ -0,0 +1,2 @@
+import { n as createAuthSystem, t as auth } from "./better-auth-CStoaWiq.mjs";
+export { auth, createAuthSystem };

package/dist/better-auth.mjs

@@ -0,0 +1,17 @@
+import "./db-BVXTgOd3.mjs";
+import "./json-oFuWgANh-O1U6k3bL.mjs";
+import "./env-DwlNAN_D-C1zHd0cf-Cdlw8sNp.mjs";
+import "./verify-CN5Qc0e-.mjs";
+import "./social-providers-DNfE9Ak7-Be5zMAEe.mjs";
+import "./plugins-BNFht2HW.mjs";
+import "./esm-C5TuvtGn.mjs";
+import "./dialect-C6_pK3V9-CPJHWkYR.mjs";
+import "./dist-CygcgJYk.mjs";
+import "./misc-CbURQDlR-sLtUwwQY.mjs";
+import "./parser-bL7W2mQ0-YdTgjtji.mjs";
+import "./client--1_AEBPu-8Ae9icC9.mjs";
+import "./db-schema.final-DWleoQm0.mjs";
+import "./adapter-factory-BTRALCLD-kJBwe70v.mjs";
+import { n as createAuthSystem, t as auth } from "./better-auth-CqfhQJYE.mjs";
+
+export { auth, createAuthSystem };