auth 1.7.0-beta.0 → 1.7.0-beta.10

package/dist/index.mjs

@@ -10,22 +10,23 @@ import path, { join } from "node:path";
 import chalk from "chalk";
 import prompts from "prompts";
 import yoctoSpinner from "yocto-spinner";
+import { APIError, BetterAuthError } from "@better-auth/core/error";
+import { betterAuth } from "better-auth";
+import * as z from "zod";
+import babelPresetReact from "@babel/preset-react";
+import babelPresetTypeScript from "@babel/preset-typescript";
+import { loadConfig } from "c12";
+import { createPathsMatcher, getTsconfig, parseTsconfig } from "get-tsconfig";
 import fs$1 from "node:fs/promises";
 import { createTelemetry, getTelemetryAuthConfig } from "@better-auth/telemetry";
 import { getAdapter } from "better-auth/db/adapter";
-import * as z from "zod";
+import { capitalizeFirstLetter, toSnakeCase } from "@better-auth/core/utils/string";
 import { initGetFieldName, initGetModelName } from "better-auth/adapters";
 import { getAuthTables } from "better-auth/db";
 import prettier, { format } from "prettier";
 import { getMigrations } from "better-auth/db/migration";
-import { capitalizeFirstLetter } from "@better-auth/core/utils/string";
 import { produceSchema } from "@mrleebo/prisma-ast";
 import Crypto from "node:crypto";
-import babelPresetReact from "@babel/preset-react";
-import babelPresetTypeScript from "@babel/preset-typescript";
-import { BetterAuthError } from "@better-auth/core/error";
-import { loadConfig } from "c12";
-import { createPathsMatcher, getTsconfig, parseTsconfig } from "get-tsconfig";
 import open from "open";
 import { env } from "@better-auth/core/env";
 import { log } from "@clack/prompts";
@@ -577,1139 +578,1415 @@ function showNextSteps(lines) {
 }
 const ai = new Command("ai").description("Interactive setup for Agent Auth — AI agent authentication").action(aiAction);
 //#endregion
-//#region src/generators/drizzle.ts
-function convertToSnakeCase(str, camelCase) {
-	if (camelCase) return str;
-	return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").toLowerCase();
+//#region src/utils/cloudflare-virtual-modules.ts
+/**
+* `cloudflare:workers` is a Workers-runtime built-in module. The CLI loads
+* `auth.ts` with jiti, outside that runtime, so a config importing it would
+* crash. It is aliased to an inert stub whose named exports mirror the real
+* module so every import links.
+*
+* Like the SvelteKit stubs, these are *named* exports that must exist at link
+* time, so the surface is enumerated by hand. The list mirrors workerd's
+* `cloudflare:workers` re-export module: the entrypoint/RPC classes are real
+* classes (so `extends` works), and the value/helper exports are recursive
+* proxies that absorb any access (so `env.MY_BINDING.get()` does not throw).
+*
+* `cloudflare:test` is intentionally NOT stubbed: it is a different module with
+* a different surface, provided only by `@cloudflare/vitest-pool-workers` for
+* test runs, and an auth config never imports it.
+*
+* @see https://github.com/cloudflare/workerd/blob/main/src/cloudflare/workers.ts
+*/
+const createModule = () => {
+	return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
+const createStub = (label) => {
+  const handler = {
+    get(_, prop) {
+      if (prop === "toString") return () => label;
+      if (prop === "valueOf") return () => label;
+      if (prop === Symbol.toPrimitive) return () => label;
+      if (prop === Symbol.toStringTag) return "Object";
+      if (prop === "then") return undefined;
+      return createStub(label + "." + String(prop));
+    },
+    apply() {
+      return createStub(label + "()");
+    },
+    construct() {
+      return createStub(label + "#instance");
+    },
+  };
+  return new Proxy(function () {}, handler);
+};
+
+class WorkerEntrypoint {
+  constructor(ctx, env) {
+    this.ctx = ctx;
+    this.env = env;
+  }
 }
-const generateDrizzleSchema = async ({ options, file, adapter }) => {
-	const tables = getAuthTables(options);
-	const filePath = file || "./auth-schema.ts";
-	const databaseType = adapter.options?.provider;
-	if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
-	const fileExist = existsSync(filePath);
-	let code = generateImport({
-		databaseType,
-		tables,
-		options
-	});
-	const getModelName = initGetModelName({
-		schema: tables,
-		usePlural: adapter.options?.adapterConfig?.usePlural
-	});
-	const getFieldName = initGetFieldName({
-		schema: tables,
-		usePlural: adapter.options?.adapterConfig?.usePlural
-	});
-	for (const tableKey in tables) {
-		const table = tables[tableKey];
-		const modelName = getModelName(tableKey);
-		const fields = table.fields;
-		function getType(name, field) {
-			if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
-			name = convertToSnakeCase(name, adapter.options?.camelCase);
-			if (field.references?.field === "id") {
-				const useNumberId = options.advanced?.database?.generateId === "serial";
-				const useUUIDs = options.advanced?.database?.generateId === "uuid";
-				if (useNumberId) if (databaseType === "pg") return `integer('${name}')`;
-				else if (databaseType === "mysql") return `int('${name}')`;
-				else return `integer('${name}')`;
-				if (useUUIDs && databaseType === "pg") return `uuid('${name}')`;
-				if (field.references.field) {
-					if (databaseType === "mysql") return `varchar('${name}', { length: 36 })`;
-				}
-				return `text('${name}')`;
-			}
-			const type = field.type;
-			if (typeof type !== "string") if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
-				sqlite: `text({ enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
-				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
-				mysql: `mysqlEnum([${type.map((x) => `'${x}'`).join(", ")}])`
-			}[databaseType];
-			else throw new TypeError(`Invalid field type for field ${name} in model ${modelName}`);
-			const dbTypeMap = {
-				string: {
-					sqlite: `text('${name}')`,
-					pg: `text('${name}')`,
-					mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
-				},
-				boolean: {
-					sqlite: `integer('${name}', { mode: 'boolean' })`,
-					pg: `boolean('${name}')`,
-					mysql: `boolean('${name}')`
-				},
-				number: {
-					sqlite: `integer('${name}')`,
-					pg: field.bigint ? `bigint('${name}', { mode: 'number' })` : `integer('${name}')`,
-					mysql: field.bigint ? `bigint('${name}', { mode: 'number' })` : `int('${name}')`
-				},
-				date: {
-					sqlite: `integer('${name}', { mode: 'timestamp_ms' })`,
-					pg: `timestamp('${name}')`,
-					mysql: `timestamp('${name}', { fsp: 3 })`
-				},
-				"number[]": {
-					sqlite: `text('${name}', { mode: "json" })`,
-					pg: field.bigint ? `bigint('${name}', { mode: 'number' }).array()` : `integer('${name}').array()`,
-					mysql: `text('${name}', { mode: 'json' })`
-				},
-				"string[]": {
-					sqlite: `text('${name}', { mode: "json" })`,
-					pg: `text('${name}').array()`,
-					mysql: `text('${name}', { mode: "json" })`
-				},
-				json: {
-					sqlite: `text('${name}', { mode: "json" })`,
-					pg: `jsonb('${name}')`,
-					mysql: `json('${name}', { mode: "json" })`
-				}
-			}[type];
-			if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
-			return dbTypeMap[databaseType];
-		}
-		let id = "";
-		const useNumberId = options.advanced?.database?.generateId === "serial";
-		if (options.advanced?.database?.generateId === "uuid" && databaseType === "pg") id = `uuid("id").default(sql\`pg_catalog.gen_random_uuid()\`).primaryKey()`;
-		else if (useNumberId) if (databaseType === "pg") id = `integer("id").generatedByDefaultAsIdentity().primaryKey()`;
-		else if (databaseType === "sqlite") id = `integer("id", { mode: "number" }).primaryKey({ autoIncrement: true })`;
-		else id = `int("id").autoincrement().primaryKey()`;
-		else if (databaseType === "mysql") id = `varchar('id', { length: 36 }).primaryKey()`;
-		else if (databaseType === "pg") id = `text('id').primaryKey()`;
-		else id = `text('id').primaryKey()`;
-		const indexes = [];
-		const assignIndexes = (indexes) => {
-			if (!indexes.length) return "";
-			const code = [`, (table) => [`];
-			for (const index of indexes) code.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
-			code.push(`]`);
-			return code.join("\n");
-		};
-		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
-					id: ${id},
-					${Object.keys(fields).map((field) => {
-			const attr = fields[field];
-			const fieldName = attr.fieldName || field;
-			let type = getType(fieldName, attr);
-			if (attr.index && !attr.unique) indexes.push({
-				type: "index",
-				name: `${modelName}_${fieldName}_idx`,
-				on: fieldName
-			});
-			else if (attr.index && attr.unique) indexes.push({
-				type: "uniqueIndex",
-				name: `${modelName}_${fieldName}_uidx`,
-				on: fieldName
-			});
-			if (attr.defaultValue !== null && typeof attr.defaultValue !== "undefined") if (typeof attr.defaultValue === "function") {
-				if (attr.type === "date" && attr.defaultValue.toString().includes("new Date()")) if (databaseType === "sqlite") type += `.default(sql\`(cast(unixepoch('subsecond') * 1000 as integer))\`)`;
-				else type += `.defaultNow()`;
-			} else if (typeof attr.defaultValue === "string") type += `.default("${attr.defaultValue}")`;
-			else type += `.default(${attr.defaultValue})`;
-			if (attr.onUpdate && attr.type === "date") {
-				if (typeof attr.onUpdate === "function") type += `.$onUpdate(${attr.onUpdate})`;
-			}
-			return `${fieldName}: ${type}${attr.required !== false ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references ? `.references(()=> ${getModelName(attr.references.model)}.${getFieldName({
-				model: attr.references.model,
-				field: attr.references.field
-			})}, { onDelete: '${attr.references.onDelete || "cascade"}' })` : ""}`;
-		}).join(",\n ")}
-					}${assignIndexes(indexes)});`;
-		code += `\n${schema}\n`;
-	}
-	let relationsString = "";
-	for (const tableKey in tables) {
-		const table = tables[tableKey];
-		const modelName = getModelName(tableKey);
-		const oneRelations = [];
-		const manyRelations = [];
-		const manyRelationsSet = /* @__PURE__ */ new Set();
-		const foreignFields = Object.entries(table.fields).filter(([_, field]) => field.references);
-		for (const [fieldName, field] of foreignFields) {
-			const referencedModel = field.references.model;
-			const relationKey = getModelName(referencedModel);
-			const fieldRef = `${getModelName(tableKey)}.${getFieldName({
-				model: tableKey,
-				field: fieldName
-			})}`;
-			const referenceRef = `${getModelName(referencedModel)}.${getFieldName({
-				model: referencedModel,
-				field: field.references.field || "id"
-			})}`;
-			oneRelations.push({
-				key: relationKey,
-				model: getModelName(referencedModel),
-				type: "one",
-				reference: {
-					field: fieldRef,
-					references: referenceRef,
-					fieldName
-				}
-			});
-		}
-		const otherModels = Object.entries(tables).filter(([modelName]) => modelName !== tableKey);
-		const modelRelationsMap = /* @__PURE__ */ new Map();
-		for (const [modelName, otherTable] of otherModels) {
-			const foreignKeysPointingHere = Object.entries(otherTable.fields).filter(([_, field]) => field.references?.model === tableKey || field.references?.model === getModelName(tableKey));
-			if (foreignKeysPointingHere.length === 0) continue;
-			const hasUnique = foreignKeysPointingHere.some(([_, field]) => !!field.unique);
-			const hasMany = foreignKeysPointingHere.some(([_, field]) => !field.unique);
-			modelRelationsMap.set(modelName, {
-				modelName,
-				hasUnique,
-				hasMany
-			});
-		}
-		for (const { modelName, hasMany } of modelRelationsMap.values()) {
-			const relationType = hasMany ? "many" : "one";
-			let relationKey = getModelName(modelName);
-			if (!adapter.options?.adapterConfig?.usePlural && relationType === "many") relationKey = `${relationKey}s`;
-			if (!manyRelationsSet.has(relationKey)) {
-				manyRelationsSet.add(relationKey);
-				manyRelations.push({
-					key: relationKey,
-					model: getModelName(modelName),
-					type: relationType
-				});
-			}
-		}
-		const relationsByModel = /* @__PURE__ */ new Map();
-		for (const relation of oneRelations) if (relation.reference) {
-			const modelKey = relation.key;
-			if (!relationsByModel.has(modelKey)) relationsByModel.set(modelKey, []);
-			relationsByModel.get(modelKey).push(relation);
-		}
-		const duplicateRelations = [];
-		const singleRelations = [];
-		for (const [_modelKey, relations] of relationsByModel.entries()) if (relations.length > 1) duplicateRelations.push(...relations);
-		else singleRelations.push(relations[0]);
-		for (const relation of duplicateRelations) if (relation.reference) {
-			const fieldName = relation.reference.fieldName;
-			const tableRelation = `export const ${`${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`} = relations(${getModelName(table.modelName)}, ({ one }) => ({
-				${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		}
-		const hasOne = singleRelations.length > 0;
-		const hasMany = manyRelations.length > 0;
-		if (hasOne && hasMany) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one, many }) => ({
-				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})` : "").filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
-				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		} else if (hasOne) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one }) => ({
-				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
-					fields: [${relation.reference.field}],
-					references: [${relation.reference.references}],
-				})` : "").filter((x) => x !== "").join(",\n ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		} else if (hasMany) {
-			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ many }) => ({
-				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
-			}))`;
-			relationsString += `\n${tableRelation}\n`;
-		}
-	}
-	code += `\n${relationsString}`;
-	return {
-		code: await prettier.format(code, { parser: "typescript" }),
-		fileName: filePath,
-		overwrite: fileExist
-	};
-};
-function generateImport({ databaseType, tables, options }) {
-	const rootImports = ["relations"];
-	const coreImports = [];
-	let hasBigint = false;
-	let hasJson = false;
-	for (const table of Object.values(tables)) {
-		for (const field of Object.values(table.fields)) {
-			if (field.bigint) hasBigint = true;
-			if (field.type === "json") hasJson = true;
-		}
-		if (hasJson && hasBigint) break;
-	}
-	const useNumberId = options.advanced?.database?.generateId === "serial";
-	const useUUIDs = options.advanced?.database?.generateId === "uuid";
-	coreImports.push(`${databaseType}Table`);
-	coreImports.push(databaseType === "mysql" ? "varchar, text" : databaseType === "pg" ? "text" : "text");
-	coreImports.push(hasBigint ? databaseType !== "sqlite" ? "bigint" : "" : "");
-	coreImports.push(databaseType !== "sqlite" ? "timestamp, boolean" : "");
-	if (databaseType === "mysql") {
-		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
-		if (useNumberId || hasNonBigintNumber) coreImports.push("int");
-		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => typeof field.type !== "string" && Array.isArray(field.type) && field.type.every((x) => typeof x === "string")))) coreImports.push("mysqlEnum");
-	} else if (databaseType === "pg") {
-		if (useUUIDs) rootImports.push("sql");
-		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
-		const hasFkToId = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.references?.field === "id"));
-		if (hasNonBigintNumber || options.advanced?.database?.generateId === "serial" && hasFkToId) coreImports.push("integer");
-	} else coreImports.push("integer");
-	if (databaseType === "pg" && useUUIDs) coreImports.push("uuid");
-	if (hasJson) {
-		if (databaseType === "pg") coreImports.push("jsonb");
-		if (databaseType === "mysql") coreImports.push("json");
-	}
-	if (databaseType === "sqlite" && Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.type === "date" && field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("new Date()")))) rootImports.push("sql");
-	const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique));
-	const hasUniqueIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.unique && field.index));
-	if (hasIndexes) coreImports.push("index");
-	if (hasUniqueIndexes) coreImports.push("uniqueIndex");
-	return `${rootImports.length > 0 ? `import { ${rootImports.join(", ")} } from "drizzle-orm";\n` : ""}import { ${coreImports.map((x) => x.trim()).filter((x) => x !== "").join(", ")} } from "drizzle-orm/${databaseType}-core";\n`;
+class DurableObject {
+  constructor(ctx, env) {
+    this.ctx = ctx;
+    this.env = env;
+  }
 }
-//#endregion
-//#region src/generators/kysely.ts
-const generateKyselySchema = async ({ options, file }) => {
-	const { compileMigrations } = await getMigrations(options);
-	const migrations = await compileMigrations();
-	return {
-		code: migrations.trim() === ";" ? "" : migrations,
-		fileName: file || `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.sql`
-	};
-};
-//#endregion
-//#region src/utils/helper.ts
-async function tryCatch(promise) {
-	try {
-		return {
-			data: await promise,
-			error: null
-		};
-	} catch (error) {
-		return {
-			data: null,
-			error
-		};
-	}
+class WorkflowEntrypoint {
+  constructor(ctx, env) {
+    this.ctx = ctx;
+    this.env = env;
+  }
 }
-const generateSecretHash = () => {
-	return Crypto.randomBytes(16).toString("hex");
+class RpcTarget {}
+class RpcStub {}
+class RpcPromise {}
+class RpcProperty {}
+class ServiceStub {}
+
+const env = createStub("env");
+const exportsStub = createStub("exports");
+const cache = createStub("cache");
+const tracing = createStub("tracing");
+const withEnv = createStub("withEnv");
+const withExports = createStub("withExports");
+const withEnvAndExports = createStub("withEnvAndExports");
+const waitUntil = createStub("waitUntil");
+const abortIsolate = createStub("abortIsolate");
+
+export {
+  WorkerEntrypoint,
+  DurableObject,
+  WorkflowEntrypoint,
+  RpcTarget,
+  RpcStub,
+  RpcPromise,
+  RpcProperty,
+  ServiceStub,
+  env,
+  exportsStub as exports,
+  cache,
+  tracing,
+  withEnv,
+  withExports,
+  withEnvAndExports,
+  waitUntil,
+  abortIsolate,
 };
-const spawnCommand = (cmd, cwd = process.cwd()) => new Promise((resolve, reject) => {
-	const child = spawn(cmd, {
-		cwd,
-		stdio: "inherit",
-		shell: true
-	});
-	child.on("close", (code, signal) => {
-		if (code !== 0 && code !== null) reject(/* @__PURE__ */ new Error(`Exited with code ${code}`));
-		else if (signal) reject(/* @__PURE__ */ new Error(`Killed with signal ${signal}`));
-		else resolve();
-	});
-	child.on("error", reject);
-});
-//#endregion
-//#region src/utils/get-package-info.ts
-function getPackageInfo(cwd) {
-	const packageJsonPath = cwd ? path.join(cwd, "package.json") : path.join("package.json");
-	return JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-}
-function getPrismaVersion(cwd) {
-	try {
-		const packageInfo = getPackageInfo(cwd);
-		const prismaVersion = packageInfo.dependencies?.prisma || packageInfo.devDependencies?.prisma || packageInfo.dependencies?.["@prisma/client"] || packageInfo.devDependencies?.["@prisma/client"];
-		if (!prismaVersion) return null;
-		const match = prismaVersion.match(/(\d+)/);
-		return match ? parseInt(match[1], 10) : null;
-	} catch {
-		return null;
-	}
+// jiti dirty hack: .unknown
+`)}`;
+};
+const CLOUDFLARE_STUB_MODULE = createModule();
+function addCloudflareVirtualModules(aliases) {
+	if (!aliases["cloudflare:workers"]) aliases["cloudflare:workers"] = CLOUDFLARE_STUB_MODULE;
 }
+//#endregion
+//#region src/utils/sveltekit-virtual-modules.ts
 /**
-* Checks if a package has a specific dependency.
+* SvelteKit exposes virtual runtime modules (`$env/*`, `$app/*`,
+* `$service-worker`) that exist only while its Vite plugin runs. The CLI loads
+* `auth.ts` with jiti, outside Vite, so a config importing them would crash the
+* loader. Each is aliased to an inert stub.
 *
-* @param packageJson The package.json object
-* @param dependency The dependency to check for
-* @returns true if the package has the dependency
+* The stubs are injected unconditionally — a non-SvelteKit config never imports
+* them, so the unused aliases are harmless, and it keeps this free of project
+* detection. Real path aliases (`$lib` and any `kit.alias`) are deliberately
+* NOT handled here: `svelte-kit sync` writes them into `.svelte-kit/tsconfig.json`,
+* which the tsconfig `paths` matcher in `get-config.ts` resolves.
+*
+* Why the export surface is enumerated by hand: these are *named* exports, and
+* ESM requires every imported name to exist at link time, so an opaque or
+* wildcard stub is impossible. (Vite asset imports are default-export and so
+* can be matched by rule in `vite-virtual-modules.ts`; a static analyzer can
+* ignore these opaquely because it never runs the module — we do, so we have to
+* provide runnable exports.) The shapes mirror SvelteKit's public, documented
+* surface, which is the stable contract; the internal `__sveltekit/*` virtual
+* modules the real files depend on are not, which is why we stub `$app/*`
+* directly rather than resolving SvelteKit's on-disk files.
+*
+* The authoritative export surfaces this mirrors:
+*
+* @see https://github.com/sveltejs/kit/tree/main/packages/kit/src/runtime/app
+* @see https://github.com/sveltejs/kit/blob/main/packages/kit/src/types/ambient.d.ts
 */
-function hasDependency(packageJson, dependency) {
-	let hasDependency = false;
-	if (packageJson.dependencies?.[dependency] || packageJson.devDependencies?.[dependency] || packageJson.peerDependencies?.[dependency] || packageJson.optionalDependencies?.[dependency]) hasDependency = true;
-	return hasDependency;
+function addSvelteKitVirtualModules(aliases) {
+	aliases["$env/dynamic/private"] = createStubModule(createDynamicEnvModule("private"));
+	aliases["$env/dynamic/public"] = createStubModule(createDynamicEnvModule("public"));
+	aliases["$env/static/private"] = createStubModule(createStaticEnvModule(filterPrivateEnv("PUBLIC_", "")));
+	aliases["$env/static/public"] = createStubModule(createStaticEnvModule(filterPublicEnv("PUBLIC_", "")));
+	for (const [id, body] of Object.entries(appModuleStubs)) aliases[id] = createStubModule(body);
 }
 /**
-* Checks if a directory is a monorepo root by looking for common monorepo indicators.
-*
-* @param dir Directory to check
-* @returns true if the directory appears to be a monorepo root
+* `$app/env` is SvelteKit's alias for `$app/environment` with an identical
+* export surface, so both specifiers share this body.
+* @see https://github.com/sveltejs/kit/pull/15934
 */
-async function isMonorepoRoot(dir) {
-	const { data: files } = await tryCatch(fs$1.readdir(dir, "utf-8"));
-	if (!files) return false;
-	if (files.includes("pnpm-workspace.yaml")) return true;
-	if (files.includes("package.json")) {
-		const packageJsonPath = path.join(dir, "package.json");
-		const { data } = await tryCatch(fs$1.readFile(packageJsonPath, "utf-8"));
-		if (data) try {
-			const packageJson = JSON.parse(data);
-			if (packageJson.workspaces && (Array.isArray(packageJson.workspaces) || typeof packageJson.workspaces === "object")) return true;
-		} catch {}
-	}
-	return [
-		"lerna.json",
-		"turbo.json",
-		"nx.json",
-		"rush.json"
-	].some((indicator) => files.includes(indicator));
+const environmentStub = `
+export const browser = false;
+export const building = false;
+export const dev = false;
+export const version = "";
+`;
+/**
+* Specifier → module source for the inert `$app/*` and `$service-worker`
+* stubs. The bodies do nothing (the CLI never serves a request); they exist
+* only so every name a config might import resolves. Keep each entry aligned
+* with SvelteKit's documented exports.
+* @see https://svelte.dev/docs/kit/$app-environment
+* @see https://svelte.dev/docs/kit/$app-server
+* @see https://svelte.dev/docs/kit/$service-worker
+*/
+const appModuleStubs = {
+	"$app/environment": environmentStub,
+	"$app/env": environmentStub,
+	"$app/server": `
+export function getRequestEvent() {}
+export function read() {}
+export function query() {}
+export function prerender() {}
+export function command() {}
+export function form() {}
+export const requested = false;
+`,
+	"$app/paths": `
+export const base = "";
+export const assets = "";
+export function resolve(path) { return path; }
+export function resolveRoute(path) { return path; }
+export function asset(value) { return value; }
+export async function match() { return null; }
+`,
+	"$app/navigation": `
+export function goto() {}
+export function invalidate() {}
+export function invalidateAll() {}
+export function preloadData() {}
+export function preloadCode() {}
+export function beforeNavigate() {}
+export function afterNavigate() {}
+export function onNavigate() {}
+export function disableScrollHandling() {}
+export function pushState() {}
+export function replaceState() {}
+export function refreshAll() {}
+`,
+	"$app/state": `
+export const page = {};
+export const navigating = {};
+export const updated = { check() { return Promise.resolve(false); } };
+`,
+	"$app/stores": `
+export const page = { subscribe() { return () => {}; } };
+export const navigating = { subscribe() { return () => {}; } };
+export const updated = { subscribe() { return () => {}; }, check() { return Promise.resolve(false); } };
+export function getStores() { return { page, navigating, updated }; }
+`,
+	"$app/forms": `
+export function applyAction() {}
+export function deserialize() {}
+export function enhance() {}
+`,
+	"$service-worker": `
+export const base = "";
+export const build = [];
+export const files = [];
+export const prerendered = [];
+export const version = "";
+`
+};
+/**
+* Wraps a module body as a `data:` URI for use as a jiti alias target. The
+* trailing marker is load-bearing: without an "extension", jiti resolves the
+* alias value as a file path and fails with ENOENT, so the comment gives it an
+* unknown extension and forces a native import instead. (Stubs injected by the
+* Babel plugin in `vite-virtual-modules.ts` set the specifier directly and do
+* not go through alias resolution, so they need no marker.)
+*/
+function createStubModule(body) {
+	const source = `${body}\n// jiti dirty hack: .unknown\n`;
+	return `data:text/javascript;charset=utf-8,${encodeURIComponent(source)}`;
+}
+function createStaticEnvModule(env) {
+	return Object.keys(env).filter((k) => validIdentifier.test(k) && !reserved.has(k)).map((k) => `export const ${k} = ${JSON.stringify(env[k])};`).join("\n");
+}
+function createDynamicEnvModule(visibility) {
+	return `
+const keep = (key) => typeof key === "string" && ${visibility === "public" ? `key.startsWith("PUBLIC_")` : `!key.startsWith("PUBLIC_")`};
+export const env = new Proxy(
+  {},
+  {
+    get: (_, key) => (keep(key) ? process.env[key] : undefined),
+    has: (_, key) => keep(key) && key in process.env,
+    ownKeys: () => Object.keys(process.env).filter(keep),
+    getOwnPropertyDescriptor: (_, key) =>
+      keep(key) && key in process.env
+        ? { value: process.env[key], enumerable: true, configurable: true }
+        : undefined,
+  },
+);`;
+}
+function filterPrivateEnv(publicPrefix, privatePrefix) {
+	return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith(privatePrefix) && (publicPrefix === "" || !k.startsWith(publicPrefix))));
+}
+function filterPublicEnv(publicPrefix, privatePrefix) {
+	return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith(publicPrefix) && (privatePrefix === "" || !k.startsWith(privatePrefix))));
 }
+const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+const reserved = new Set([
+	"do",
+	"if",
+	"in",
+	"for",
+	"let",
+	"new",
+	"try",
+	"var",
+	"case",
+	"else",
+	"enum",
+	"eval",
+	"null",
+	"this",
+	"true",
+	"void",
+	"with",
+	"await",
+	"break",
+	"catch",
+	"class",
+	"const",
+	"false",
+	"super",
+	"throw",
+	"while",
+	"yield",
+	"delete",
+	"export",
+	"import",
+	"public",
+	"return",
+	"static",
+	"switch",
+	"typeof",
+	"default",
+	"extends",
+	"finally",
+	"package",
+	"private",
+	"continue",
+	"debugger",
+	"function",
+	"arguments",
+	"interface",
+	"protected",
+	"implements",
+	"instanceof"
+]);
+//#endregion
+//#region src/utils/vite-virtual-modules.ts
 /**
-* Finds the monorepo root by walking up the directory tree.
+* Stub modules for Vite's "special" imports (asset and query-suffixed
+* modules). Vite resolves these through its plugin pipeline at build time; the
+* CLI loads auth configs with jiti, where no such pipeline exists and there is
+* no file on disk to read. Without a substitute, a config that transitively
+* imports e.g. `./logo.svg`, `./app.css?inline`, or `./worker.ts?worker`
+* crashes the loader.
 *
-* @param startDir Starting directory
-* @returns Path to monorepo root, or null if not found
+* Detection mirrors Vite's own classification. The query-suffix patterns are
+* tested against the full specifier, the extension membership against the
+* specifier with its query stripped, and query patterns take precedence over
+* extension membership (so `./a.css?raw` is raw text, not a stylesheet). The
+* regexes are not part of Vite's public API, so they are copied here.
+*
+* @see https://github.com/vitejs/vite/blob/main/packages/vite/src/node/constants.ts
+* @see https://github.com/vitejs/vite/blob/main/packages/vite/src/node/plugins/asset.ts
 */
-async function findMonorepoRoot(startDir) {
-	let currentDir = path.resolve(startDir);
-	const root = path.parse(currentDir).root;
-	while (currentDir !== root) {
-		if (await isMonorepoRoot(currentDir)) return currentDir;
-		const parentDir = path.dirname(currentDir);
-		if (parentDir === currentDir) break;
-		currentDir = parentDir;
-	}
-	return null;
+const WORKER_RE = /[?&](?:worker|sharedworker)(?:&|$)/;
+const URL_RE = /[?&]url(?:&|$)/;
+const RAW_RE = /[?&]raw(?:&|$)/;
+const INLINE_RE = /[?&]inline(?:&|$)/;
+const WASM_INIT_RE = /\.wasm\?init\b/;
+const CSS_MODULE_RE = /\.module\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const CSS_LANGS_RE = /\.(?:css|less|sass|scss|styl|stylus|pcss|postcss|sss)(?:$|\?)/;
+const KNOWN_ASSET_RE = /\.(?:apng|bmp|png|jpe?g|jfif|pjpeg|pjp|gif|svg|ico|webp|avif|cur|jxl|mp4|webm|ogg|mp3|wav|flac|aac|opus|mov|m4a|vtt|woff2?|eot|ttf|otf|webmanifest|pdf|txt)(?:\?.*)?$/i;
+function createDataUriModule(body) {
+	return `data:text/javascript;charset=utf-8,${encodeURIComponent(body)}`;
 }
-//#endregion
-//#region src/generators/prisma.ts
-const generatePrismaSchema = async ({ adapter, options, file }) => {
-	const provider = adapter.options?.provider || "postgresql";
-	const tables = getAuthTables(options);
-	const filePath = file || "./prisma/schema.prisma";
-	const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
-	const getModelName = initGetModelName({
-		schema: getAuthTables(options),
-		usePlural: adapter.options?.adapterConfig?.usePlural
-	});
-	const getFieldName = initGetFieldName({
-		schema: getAuthTables(options),
-		usePlural: false
-	});
-	let schemaPrisma = "";
-	if (schemaPrismaExist) schemaPrisma = await fs$1.readFile(path.join(process.cwd(), filePath), "utf-8");
-	else schemaPrisma = getNewPrisma(provider, process.cwd());
-	const prismaVersion = getPrismaVersion(process.cwd());
-	if (prismaVersion && prismaVersion >= 7 && schemaPrismaExist) schemaPrisma = produceSchema(schemaPrisma, (builder) => {
-		const generator = builder.findByType("generator", { name: "client" });
-		if (generator && generator.properties) {
-			const providerProp = generator.properties.find((prop) => prop.type === "assignment" && prop.key === "provider");
-			if (providerProp && providerProp.value === "\"prisma-client-js\"") providerProp.value = "\"prisma-client\"";
+/**
+* Returns a data-URI stub module for a Vite special import, or `undefined`
+* when the specifier is an ordinary module that should resolve normally. The
+* stub's runtime shape matches what Vite would emit (a string for raw/url, a
+* worker constructor, a class-name proxy for CSS Modules, and so on).
+*/
+function getViteAssetStub(specifier) {
+	if (WORKER_RE.test(specifier)) return createDataUriModule(URL_RE.test(specifier) ? `export default "";` : `export default function () {};`);
+	if (WASM_INIT_RE.test(specifier)) return createDataUriModule(`export default async () => ({ exports: {} });`);
+	if (RAW_RE.test(specifier) || INLINE_RE.test(specifier) || URL_RE.test(specifier)) return createDataUriModule(`export default "";`);
+	if (CSS_MODULE_RE.test(specifier)) return createDataUriModule(`export default new Proxy({}, { get: (_, key) => String(key) });`);
+	if (CSS_LANGS_RE.test(specifier)) return createDataUriModule(`export default undefined;`);
+	if (KNOWN_ASSET_RE.test(specifier)) return createDataUriModule(`export default "";`);
+}
+//#endregion
+//#region src/utils/get-config.ts
+let possiblePaths$1 = [
+	"auth.ts",
+	"auth.tsx",
+	"auth.js",
+	"auth.jsx",
+	"auth.server.js",
+	"auth.server.ts",
+	"auth/index.ts",
+	"auth/index.tsx",
+	"auth/index.js",
+	"auth/index.jsx",
+	"auth/index.server.js",
+	"auth/index.server.ts"
+];
+possiblePaths$1 = [
+	...possiblePaths$1,
+	...possiblePaths$1.map((it) => `lib/server/${it}`),
+	...possiblePaths$1.map((it) => `server/auth/${it}`),
+	...possiblePaths$1.map((it) => `server/${it}`),
+	...possiblePaths$1.map((it) => `auth/${it}`),
+	...possiblePaths$1.map((it) => `lib/${it}`),
+	...possiblePaths$1.map((it) => `utils/${it}`)
+];
+possiblePaths$1 = [
+	...possiblePaths$1,
+	...possiblePaths$1.map((it) => `src/${it}`),
+	...possiblePaths$1.map((it) => `app/${it}`)
+];
+/** Reads `references` from raw tsconfig JSON (stripped out by `parseTsconfig`). */
+function readRawTsconfigReferences(tsconfigPath) {
+	try {
+		const stripped = fs.readFileSync(tsconfigPath, "utf-8").replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m).replace(/,(?=\s*[}\]])/g, "");
+		return JSON.parse(stripped).references;
+	} catch {
+		return;
+	}
+}
+/** Recursively collects tsconfigs reachable via `references`. */
+function collectReferencedTsconfigs(tsconfigPath, visited = /* @__PURE__ */ new Set()) {
+	const result = [];
+	const refs = readRawTsconfigReferences(tsconfigPath);
+	if (!refs) return result;
+	const configDir = path.dirname(tsconfigPath);
+	for (const ref of refs) {
+		const resolvedRef = path.resolve(configDir, ref.path);
+		const refTsconfigPath = resolvedRef.endsWith(".json") ? resolvedRef : path.join(resolvedRef, "tsconfig.json");
+		if (visited.has(refTsconfigPath)) continue;
+		visited.add(refTsconfigPath);
+		try {
+			const refConfig = parseTsconfig(refTsconfigPath);
+			result.push({
+				path: refTsconfigPath,
+				config: refConfig
+			});
+		} catch {
+			continue;
 		}
-		const datasource = builder.findByType("datasource", { name: "db" });
-		if (datasource && datasource.properties) {
-			const urlIndex = datasource.properties.findIndex((prop) => prop.type === "assignment" && prop.key === "url");
-			if (urlIndex !== -1) datasource.properties.splice(urlIndex, 1);
+		result.push(...collectReferencedTsconfigs(refTsconfigPath, visited));
+	}
+	return result;
+}
+/**
+* Ordered `paths` matchers from the project tsconfig and any referenced
+* tsconfigs, following TypeScript canonical resolution semantics.
+* @see https://github.com/microsoft/TypeScript/blob/main/src/compiler/moduleNameResolver.ts
+*/
+function collectPathsMatchers(cwd) {
+	const tsconfig = getTsconfig(cwd, fs.existsSync(path.join(cwd, "tsconfig.json")) ? "tsconfig.json" : "jsconfig.json");
+	if (!tsconfig) return [];
+	const matchers = [];
+	try {
+		const mainMatcher = createPathsMatcher(tsconfig);
+		if (mainMatcher) matchers.push(mainMatcher);
+		for (const refTsconfig of collectReferencedTsconfigs(tsconfig.path)) {
+			const refMatcher = createPathsMatcher(refTsconfig);
+			if (refMatcher) matchers.push(refMatcher);
 		}
-	});
-	const manyToManyRelations = /* @__PURE__ */ new Map();
-	for (const table in tables) {
-		const fields = tables[table]?.fields;
-		for (const field in fields) {
-			const attr = fields[field];
-			if (attr.references) {
-				const referencedOriginalModel = attr.references.model;
-				const referencedModelNameCap = capitalizeFirstLetter(getModelName(tables[referencedOriginalModel]?.modelName || referencedOriginalModel));
-				if (!manyToManyRelations.has(referencedModelNameCap)) manyToManyRelations.set(referencedModelNameCap, /* @__PURE__ */ new Set());
-				const currentModelNameCap = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
-				manyToManyRelations.get(referencedModelNameCap).add(currentModelNameCap);
+	} catch (error) {
+		console.error(error);
+		throw new BetterAuthError("Error parsing tsconfig.json");
+	}
+	return matchers;
+}
+/**
+* Source file extensions jiti can load. Shared between the jiti `extensions`
+* option and `resolveCandidateFile` so both stay in sync.
+*/
+const SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs"
+];
+const SOURCE_EXTENSIONS_SET = new Set(SOURCE_EXTENSIONS);
+/** Probes a candidate as-is, with known extensions, and as a directory index. */
+function resolveCandidateFile(candidate) {
+	try {
+		if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
+	} catch {}
+	if (SOURCE_EXTENSIONS_SET.has(path.extname(candidate))) return;
+	for (const ext of SOURCE_EXTENSIONS) {
+		const withExt = candidate + ext;
+		if (fs.existsSync(withExt)) return withExt;
+	}
+	for (const ext of SOURCE_EXTENSIONS) {
+		const asIndex = path.join(candidate, `index${ext}`);
+		if (fs.existsSync(asIndex)) return asIndex;
+	}
+}
+function resolveWithMatchers(specifier, matchers) {
+	for (const matcher of matchers) for (const candidate of matcher(specifier)) {
+		const resolved = resolveCandidateFile(candidate);
+		if (resolved) return resolved;
+	}
+}
+/**
+* Callees whose first string argument is a module specifier. `jitiImport` is
+* a jiti-side preprocessor artifact observed in the AST; revisit on jiti
+* major version bumps (the regression suite catches a rename but not the why).
+*/
+const LOADER_IDENTIFIERS = new Set([
+	"require",
+	"import",
+	"jitiImport"
+]);
+/**
+* Rewrites aliased specifiers at AST level. Required because jiti's `alias`
+* option only supports prefix matching and cannot express mid-path wildcards.
+*
+* Matchers always take precedence over native resolution, mirroring
+* TypeScript's own `paths` → `node_modules` order.
+*/
+function createRewriteImportPathsPlugin(matchers) {
+	return ({ types: t }) => {
+		const rewrite = (source) => {
+			if (!source) return;
+			const stub = getViteAssetStub(source.value);
+			if (stub) {
+				source.value = stub;
+				return;
+			}
+			const resolved = resolveWithMatchers(source.value, matchers);
+			if (resolved) source.value = resolved;
+		};
+		return { visitor: {
+			ImportDeclaration(p) {
+				rewrite(p.node.source);
+			},
+			ExportNamedDeclaration(p) {
+				rewrite(p.node.source);
+			},
+			ExportAllDeclaration(p) {
+				rewrite(p.node.source);
+			},
+			ImportExpression(p) {
+				if (t.isStringLiteral(p.node.source)) rewrite(p.node.source);
+			},
+			CallExpression(p) {
+				const { callee, arguments: args } = p.node;
+				const first = args[0];
+				if (!t.isStringLiteral(first)) return;
+				if (!(t.isIdentifier(callee) && LOADER_IDENTIFIERS.has(callee.name) || t.isImport(callee))) return;
+				rewrite(first);
 			}
+		} };
+	};
+}
+/** Virtual module aliases; real tsconfig paths go through the babel plugin. */
+function getVirtualModuleAliases() {
+	const result = {};
+	addSvelteKitVirtualModules(result);
+	addCloudflareVirtualModules(result);
+	return result;
+}
+/**
+* .tsx files are not supported by Jiti.
+*/
+const jitiOptions = (cwd) => {
+	const plugins = [createRewriteImportPathsPlugin(collectPathsMatchers(cwd))];
+	return {
+		transformOptions: { babel: {
+			presets: [[babelPresetTypeScript, {
+				isTSX: true,
+				allExtensions: true
+			}], [babelPresetReact, { runtime: "automatic" }]],
+			plugins
+		} },
+		extensions: [...SOURCE_EXTENSIONS],
+		alias: getVirtualModuleAliases()
+	};
+};
+/**
+* Picks the auth instance from the loaded module, supporting `export const auth`,
+* `export default auth`, and `export default { auth }`. Falls back to the raw
+* module as a defensive default.
+*/
+const resolveAuthModule = (mod) => {
+	const m = mod;
+	return m?.auth ?? m?.default?.auth ?? m?.default ?? mod;
+};
+const isServerOnlyError = (e) => typeof e === "object" && e !== null && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module");
+const SERVER_ONLY_HINT = `Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`;
+async function getConfig({ cwd, configPath, shouldThrowOnError = false }) {
+	const fail = (message, error) => {
+		if (shouldThrowOnError) throw error instanceof Error ? error : new Error(message);
+		const log = `[#better-auth]: ${message}`;
+		if (error) console.error(log, error);
+		else console.error(log);
+		process.exit(1);
+	};
+	const load = (configFile) => loadConfig({
+		configFile,
+		dotenv: { fileName: [".env", ".env.local"] },
+		jitiOptions: jitiOptions(cwd),
+		resolveModule: resolveAuthModule,
+		cwd
+	});
+	try {
+		if (configPath) {
+			const resolvedPath = existsSync(configPath) ? configPath : path.join(cwd, configPath);
+			const { config } = await load(resolvedPath);
+			const options = config?.options;
+			if (!options) return fail(`Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`);
+			return options;
 		}
-	}
-	const indexedFields = /* @__PURE__ */ new Map();
-	for (const table in tables) {
-		const fields = tables[table]?.fields;
-		const modelName = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
-		indexedFields.set(modelName, []);
-		for (const field in fields) {
-			const attr = fields[field];
-			if (attr.index && !attr.unique) {
-				const fieldName = attr.fieldName || field;
-				indexedFields.get(modelName).push(fieldName);
+		for (const possiblePath of possiblePaths$1) {
+			let config;
+			try {
+				({config} = await load(possiblePath));
+			} catch (e) {
+				if (isServerOnlyError(e)) return fail(SERVER_ONLY_HINT);
+				return fail("Couldn't read your auth config.", e);
 			}
+			if (Object.keys(config).length === 0) continue;
+			if (!config.options) return fail("Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth.");
+			return config.options;
 		}
+		return null;
+	} catch (e) {
+		if (isServerOnlyError(e)) return fail(SERVER_ONLY_HINT);
+		return fail("Couldn't read your auth config.", e);
 	}
-	const schema = produceSchema(schemaPrisma, (builder) => {
-		for (const table in tables) {
-			const originalTableName = table;
-			const customModelName = tables[table]?.modelName || table;
-			const modelName = capitalizeFirstLetter(getModelName(customModelName));
-			const fields = tables[table]?.fields;
-			function getType({ isBigint, isOptional, type }) {
-				if (type === "string") return isOptional ? "String?" : "String";
-				if (type === "number" && isBigint) return isOptional ? "BigInt?" : "BigInt";
-				if (type === "number") return isOptional ? "Int?" : "Int";
-				if (type === "boolean") return isOptional ? "Boolean?" : "Boolean";
-				if (type === "date") return isOptional ? "DateTime?" : "DateTime";
-				if (type === "json") {
-					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
-					return isOptional ? "Json?" : "Json";
-				}
-				if (type === "string[]") {
-					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
-					return "String[]";
-				}
-				if (type === "number[]") {
-					if (provider === "sqlite" || provider === "mysql") return "String";
-					return "Int[]";
-				}
-			}
-			const prismaModel = builder.findByType("model", { name: modelName });
-			if (!prismaModel) if (provider === "mongodb") builder.model(modelName).field("id", "String").attribute("id").attribute(`map("_id")`);
-			else {
-				const useNumberId = options.advanced?.database?.generateId === "serial";
-				const useUUIDs = options.advanced?.database?.generateId === "uuid";
-				if (useNumberId) builder.model(modelName).field("id", "Int").attribute("id").attribute("default(autoincrement())");
-				else if (useUUIDs && provider === "postgresql") builder.model(modelName).field("id", "String").attribute("id").attribute("default(dbgenerated(\"pg_catalog.gen_random_uuid()\"))").attribute("db.Uuid");
-				else builder.model(modelName).field("id", "String").attribute("id");
-			}
-			for (const field in fields) {
-				const attr = fields[field];
-				const fieldName = attr.fieldName || field;
-				if (prismaModel) {
-					if (builder.findByType("field", {
-						name: fieldName,
-						within: prismaModel.properties
-					})) continue;
-				}
-				const useUUIDs = options.advanced?.database?.generateId === "uuid";
-				const useNumberId = options.advanced?.database?.generateId === "serial";
-				const fieldBuilder = builder.model(modelName).field(fieldName, field === "id" && useNumberId ? getType({
-					isBigint: false,
-					isOptional: false,
-					type: "number"
-				}) : getType({
-					isBigint: attr?.bigint || false,
-					isOptional: attr?.required === false,
-					type: attr.references?.field === "id" ? useNumberId ? "number" : "string" : attr.type
-				}));
-				if (field === "id") {
-					fieldBuilder.attribute("id");
-					if (provider === "mongodb") fieldBuilder.attribute(`map("_id")`);
-				}
-				if (attr.unique) builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
-				if (attr.defaultValue !== void 0) {
-					if (Array.isArray(attr.defaultValue)) {
-						if (attr.type === "json") {
-							if (Object.prototype.toString.call(attr.defaultValue[0]) === "[object Object]") {
-								fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
-								continue;
-							}
-							const jsonArray = [];
-							for (const value of attr.defaultValue) jsonArray.push(value);
-							fieldBuilder.attribute(`default("${JSON.stringify(jsonArray).replace(/"/g, "\\\"")}")`);
-							continue;
-						}
-						if (attr.defaultValue.length === 0) {
-							fieldBuilder.attribute(`default([])`);
-							continue;
-						} else if (typeof attr.defaultValue[0] === "string" && attr.type === "string[]") {
-							const valueArray = [];
-							for (const value of attr.defaultValue) valueArray.push(JSON.stringify(value));
-							fieldBuilder.attribute(`default([${valueArray}])`);
-						} else if (typeof attr.defaultValue[0] === "number") {
-							const valueArray = [];
-							for (const value of attr.defaultValue) valueArray.push(`${value}`);
-							fieldBuilder.attribute(`default([${valueArray}])`);
-						}
-					} else if (typeof attr.defaultValue === "object" && !Array.isArray(attr.defaultValue) && attr.defaultValue !== null) {
-						if (Object.entries(attr.defaultValue).length === 0) {
-							fieldBuilder.attribute(`default("{}")`);
-							continue;
-						}
-						fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
-					}
-					if (field === "createdAt") fieldBuilder.attribute("default(now())");
-					else if (typeof attr.defaultValue === "string" && provider !== "mysql") fieldBuilder.attribute(`default("${attr.defaultValue}")`);
-					else if (typeof attr.defaultValue === "boolean" || typeof attr.defaultValue === "number") fieldBuilder.attribute(`default(${attr.defaultValue})`);
-					else if (typeof attr.defaultValue === "function") {}
-				}
-				if (field === "updatedAt" && attr.onUpdate) fieldBuilder.attribute("updatedAt");
-				else if (attr.onUpdate) {}
-				if (attr.references) {
-					if (useUUIDs && provider === "postgresql" && attr.references?.field === "id") builder.model(modelName).field(fieldName).attribute(`db.Uuid`);
-					const referencedOriginalModelName = getModelName(attr.references.model);
-					const referencedCustomModelName = tables[referencedOriginalModelName]?.modelName || referencedOriginalModelName;
-					let action = "Cascade";
-					if (attr.references.onDelete === "no action") action = "NoAction";
-					else if (attr.references.onDelete === "set null") action = "SetNull";
-					else if (attr.references.onDelete === "set default") action = "SetDefault";
-					else if (attr.references.onDelete === "restrict") action = "Restrict";
-					const relationField = `relation(fields: [${getFieldName({
-						model: originalTableName,
-						field: fieldName
-					})}], references: [${getFieldName({
-						model: attr.references.model,
-						field: attr.references.field
-					})}], onDelete: ${action})`;
-					builder.model(modelName).field(referencedCustomModelName.toLowerCase(), `${capitalizeFirstLetter(referencedCustomModelName)}${attr.required === false ? "?" : ""}`).attribute(relationField);
-				}
-				if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") builder.model(modelName).field(fieldName).attribute("db.Text");
-			}
-			if (manyToManyRelations.has(modelName)) for (const relatedModel of manyToManyRelations.get(modelName)) {
-				const relatedTableName = Object.keys(tables).find((key) => capitalizeFirstLetter(tables[key]?.modelName || key) === relatedModel);
-				const relatedFields = relatedTableName ? tables[relatedTableName]?.fields : {};
-				const [_fieldKey, fkFieldAttr] = Object.entries(relatedFields || {}).find(([_fieldName, fieldAttr]) => fieldAttr.references && getModelName(fieldAttr.references.model) === getModelName(originalTableName)) || [];
-				const isUnique = fkFieldAttr?.unique === true;
-				const fieldName = isUnique || adapter.options?.usePlural === true ? `${relatedModel.toLowerCase()}` : `${relatedModel.toLowerCase()}s`;
-				if (!builder.findByType("field", {
-					name: fieldName,
-					within: prismaModel?.properties
-				})) builder.model(modelName).field(fieldName, `${relatedModel}${isUnique ? "?" : "[]"}`);
-			}
-			const indexedFieldsForModel = indexedFields.get(modelName);
-			if (indexedFieldsForModel && indexedFieldsForModel.length > 0) for (const fieldName of indexedFieldsForModel) {
-				if (prismaModel) {
-					if (prismaModel.properties.some((v) => v.type === "attribute" && v.name === "index" && JSON.stringify(v.args[0]?.value).includes(fieldName))) continue;
-				}
-				const field = Object.entries(fields).find(([key, attr]) => (attr.fieldName || key) === fieldName)?.[1];
-				let indexField = fieldName;
-				if (provider === "mysql" && field && field.type === "string") {
-					const useNumberId = options.advanced?.database?.generateId === "serial";
-					const useUUIDs = options.advanced?.database?.generateId === "uuid";
-					if (field.references?.field === "id" && (useNumberId || useUUIDs)) indexField = `${fieldName}`;
-					else indexField = `${fieldName}(length: 191)`;
-				}
-				builder.model(modelName).blockAttribute(`index([${indexField}])`);
-			}
-			const hasAttribute = builder.findByType("attribute", {
-				name: "map",
-				within: prismaModel?.properties
-			});
-			const hasChanged = customModelName !== originalTableName;
-			if (!hasAttribute) builder.model(modelName).blockAttribute("map", `${getModelName(hasChanged ? customModelName : originalTableName)}`);
-		}
-	});
-	const schemaChanged = schema.trim() !== schemaPrisma.trim();
-	return {
-		code: schemaChanged ? schema : "",
-		fileName: filePath,
-		overwrite: schemaPrismaExist && schemaChanged
-	};
-};
-const getNewPrisma = (provider, cwd) => {
-	const prismaVersion = getPrismaVersion(cwd);
-	const isV7 = prismaVersion && prismaVersion >= 7;
-	const clientProvider = isV7 ? "prisma-client" : "prisma-client-js";
-	if (isV7) return `generator client {
-    provider = "${clientProvider}"
-  }
-
-  datasource db {
-    provider = "${provider}"
-  }`;
-	return `generator client {
-    provider = "${clientProvider}"
-  }
-
-  datasource db {
-    provider = "${provider}"
-    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
-  }`;
-};
-//#endregion
-//#region src/generators/index.ts
-const adapters = {
-	prisma: generatePrismaSchema,
-	drizzle: generateDrizzleSchema,
-	kysely: generateKyselySchema
-};
-const generateSchema = (opts) => {
-	const adapter = opts.adapter;
-	const generator = adapter.id in adapters ? adapters[adapter.id] : null;
-	if (generator) return generator(opts);
-	if (adapter.createSchema) return adapter.createSchema(opts.options, opts.file).then(({ code, path: fileName, overwrite }) => ({
-		code,
-		fileName,
-		overwrite
-	}));
-	throw new Error(`${adapter.id} is not supported. If it is a custom adapter, please request the maintainer to implement createSchema`);
-};
-//#endregion
-//#region src/utils/add-cloudflare-modules.ts
-const createModule = () => {
-	return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
-const createStub = (label) => {
-  const handler = {
-    get(_, prop) {
-      if (prop === "toString") return () => label;
-      if (prop === "valueOf") return () => label;
-      if (prop === Symbol.toPrimitive) return () => label;
-      if (prop === Symbol.toStringTag) return "Object";
-      if (prop === "then") return undefined;
-      return createStub(label + "." + String(prop));
-    },
-    apply(_, __, args) {
-      return createStub(label + "()")
-    },
-    construct() {
-      return createStub(label + "#instance");
-    },
-  };
-  const fn = () => createStub(label + "()");
-  return new Proxy(fn, handler);
-};
-
-class WorkerEntrypoint {
-  constructor(ctx, env) {
-    this.ctx = ctx;
-    this.env = env;
-  }
-}
-
-class DurableObject {
-  constructor(state, env) {
-    this.state = state;
-    this.env = env;
-  }
-}
-
-class RpcTarget {
-  constructor(value) {
-    this.value = value;
-  }
-}
-
-const RpcStub = RpcTarget;
-
-const env = createStub("env");
-const caches = createStub("caches");
-const scheduler = createStub("scheduler");
-const executionCtx = createStub("executionCtx");
-
-export { DurableObject, RpcStub, RpcTarget, WorkerEntrypoint, caches, env, executionCtx, scheduler };
-
-const defaultExport = {
-  DurableObject,
-  RpcStub,
-  RpcTarget,
-  WorkerEntrypoint,
-  caches,
-  env,
-  executionCtx,
-  scheduler,
-};
-
-export default defaultExport;
-// jiti dirty hack: .unknown
-`)}`;
-};
-const CLOUDFLARE_STUB_MODULE = createModule();
-function addCloudflareModules(aliases, _cwd) {
-	if (!aliases["cloudflare:workers"]) aliases["cloudflare:workers"] = CLOUDFLARE_STUB_MODULE;
-	if (!aliases["cloudflare:test"]) aliases["cloudflare:test"] = CLOUDFLARE_STUB_MODULE;
 }
 //#endregion
-//#region src/utils/add-svelte-kit-env-modules.ts
-/**
-* Adds SvelteKit environment modules and path aliases
-* @param aliases - The aliases object to populate
-* @param cwd - Current working directory (optional, defaults to process.cwd())
-*/
-function addSvelteKitEnvModules(aliases, cwd) {
-	const workingDir = cwd || process.cwd();
-	aliases["$env/dynamic/private"] = createDataUriModule(createDynamicEnvModule());
-	aliases["$env/dynamic/public"] = createDataUriModule(createDynamicEnvModule());
-	aliases["$env/static/private"] = createDataUriModule(createStaticEnvModule(filterPrivateEnv("PUBLIC_", "")));
-	aliases["$env/static/public"] = createDataUriModule(createStaticEnvModule(filterPublicEnv("PUBLIC_", "")));
-	const svelteKitAliases = getSvelteKitPathAliases(workingDir);
-	Object.assign(aliases, svelteKitAliases);
+//#region src/commands/create-admin.ts
+function exitWithError(message) {
+	console.error(chalk.red(`Error: ${message}`));
+	process.exit(1);
 }
-function getSvelteKitPathAliases(cwd) {
-	const aliases = {};
-	const packageJsonPath = path.join(cwd, "package.json");
-	const svelteConfigPath = path.join(cwd, "svelte.config.js");
-	const svelteConfigTsPath = path.join(cwd, "svelte.config.ts");
-	let isSvelteKitProject = false;
-	if (fs.existsSync(packageJsonPath)) try {
-		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
-		isSvelteKitProject = !!{
-			...packageJson.dependencies,
-			...packageJson.devDependencies
-		}["@sveltejs/kit"];
-	} catch {}
-	if (!isSvelteKitProject) isSvelteKitProject = fs.existsSync(svelteConfigPath) || fs.existsSync(svelteConfigTsPath);
-	if (!isSvelteKitProject) return aliases;
-	const libPaths = [path.join(cwd, "src", "lib"), path.join(cwd, "lib")];
-	for (const libPath of libPaths) if (fs.existsSync(libPath)) {
-		aliases["$lib"] = libPath;
-		for (const subPath of [
-			"server",
-			"utils",
-			"components",
-			"stores"
-		]) {
-			const subDir = path.join(libPath, subPath);
-			if (fs.existsSync(subDir)) aliases[`$lib/${subPath}`] = subDir;
-		}
-		break;
+function parseData(data) {
+	if (!data) return void 0;
+	try {
+		const parsed = JSON.parse(data);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) exitWithError("--data must be a JSON object.");
+		return parsed;
+	} catch (error) {
+		if (error instanceof SyntaxError) exitWithError("--data must be valid JSON.");
+		throw error;
 	}
-	aliases["$app/server"] = createDataUriModule(createAppServerModule());
-	const customAliases = getSvelteConfigAliases(cwd);
-	Object.assign(aliases, customAliases);
-	return aliases;
 }
-function getSvelteConfigAliases(cwd) {
-	const aliases = {};
-	const configPaths = [path.join(cwd, "svelte.config.js"), path.join(cwd, "svelte.config.ts")];
-	for (const configPath of configPaths) if (fs.existsSync(configPath)) {
-		try {
-			const aliasMatch = fs.readFileSync(configPath, "utf-8").match(/alias\s*:\s*\{([^}]+)\}/);
-			if (aliasMatch && aliasMatch[1]) {
-				const aliasMatches = aliasMatch[1].matchAll(/['"`](\$[^'"`]+)['"`]\s*:\s*['"`]([^'"`]+)['"`]/g);
-				for (const match of aliasMatches) {
-					const [, alias, target] = match;
-					if (alias && target) {
-						aliases[alias + "/*"] = path.resolve(cwd, target) + "/*";
-						aliases[alias] = path.resolve(cwd, target);
-					}
-				}
-			}
-		} catch {}
-		break;
-	}
-	return aliases;
+async function resolveRequiredInput(options) {
+	let { email, password } = options;
+	if (!email) email = (await prompts({
+		type: "text",
+		name: "email",
+		message: "Admin email"
+	})).email;
+	if (!password) password = (await prompts({
+		type: "password",
+		name: "password",
+		message: "Admin password"
+	})).password;
+	if (!email) exitWithError("Admin email is required.");
+	if (!password) exitWithError("Admin password is required.");
+	return {
+		email,
+		password
+	};
 }
-function createAppServerModule() {
-	return `
-// $app/server stub for CLI compatibility
-export default {};
-// jiti dirty hack: .unknown
-`;
-}
-function createDataUriModule(module) {
-	return `data:text/javascript;charset=utf-8,${encodeURIComponent(module)}`;
-}
-function createStaticEnvModule(env) {
-	return `
-  ${Object.keys(env).filter((k) => validIdentifier.test(k) && !reserved.has(k)).map((k) => `export const ${k} = ${JSON.stringify(env[k])};`).join("\n")}
-  // jiti dirty hack: .unknown
-  `;
-}
-function createDynamicEnvModule() {
-	return `
-  export const env = process.env;
-  // jiti dirty hack: .unknown
-  `;
-}
-function filterPrivateEnv(publicPrefix, privatePrefix) {
-	return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith(privatePrefix) && (publicPrefix === "" || !k.startsWith(publicPrefix))));
-}
-function filterPublicEnv(publicPrefix, privatePrefix) {
-	return Object.fromEntries(Object.entries(process.env).filter(([k]) => k.startsWith(publicPrefix) && (privatePrefix === "" || !k.startsWith(privatePrefix))));
-}
-const validIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
-const reserved = new Set([
-	"do",
-	"if",
-	"in",
-	"for",
-	"let",
-	"new",
-	"try",
-	"var",
-	"case",
-	"else",
-	"enum",
-	"eval",
-	"null",
-	"this",
-	"true",
-	"void",
-	"with",
-	"await",
-	"break",
-	"catch",
-	"class",
-	"const",
-	"false",
-	"super",
-	"throw",
-	"while",
-	"yield",
-	"delete",
-	"export",
-	"import",
-	"public",
-	"return",
-	"static",
-	"switch",
-	"typeof",
-	"default",
-	"extends",
-	"finally",
-	"package",
-	"private",
-	"continue",
-	"debugger",
-	"function",
-	"arguments",
-	"interface",
-	"protected",
-	"implements",
-	"instanceof"
-]);
-//#endregion
-//#region src/utils/get-config.ts
-let possiblePaths$1 = [
-	"auth.ts",
-	"auth.tsx",
-	"auth.js",
-	"auth.jsx",
-	"auth.server.js",
-	"auth.server.ts",
-	"auth/index.ts",
-	"auth/index.tsx",
-	"auth/index.js",
-	"auth/index.jsx",
-	"auth/index.server.js",
-	"auth/index.server.ts"
-];
-possiblePaths$1 = [
-	...possiblePaths$1,
-	...possiblePaths$1.map((it) => `lib/server/${it}`),
-	...possiblePaths$1.map((it) => `server/auth/${it}`),
-	...possiblePaths$1.map((it) => `server/${it}`),
-	...possiblePaths$1.map((it) => `auth/${it}`),
-	...possiblePaths$1.map((it) => `lib/${it}`),
-	...possiblePaths$1.map((it) => `utils/${it}`)
-];
-possiblePaths$1 = [
-	...possiblePaths$1,
-	...possiblePaths$1.map((it) => `src/${it}`),
-	...possiblePaths$1.map((it) => `app/${it}`)
-];
-/** Reads `references` from raw tsconfig JSON (stripped out by `parseTsconfig`). */
-function readRawTsconfigReferences(tsconfigPath) {
+/** @internal */
+async function createAdminAction(opts) {
+	const options = z.object({
+		cwd: z.string(),
+		config: z.string().optional(),
+		email: z.string().optional(),
+		password: z.string().optional(),
+		name: z.string().default("Admin"),
+		role: z.string().default("admin"),
+		data: z.string().optional(),
+		emailVerified: z.boolean().default(true),
+		force: z.boolean().optional(),
+		y: z.boolean().optional(),
+		yes: z.boolean().optional()
+	}).parse(opts);
+	const cwd = path.resolve(options.cwd);
+	if (!existsSync(cwd)) exitWithError(`The directory "${cwd}" does not exist.`);
+	if (options.y) {
+		console.warn("WARNING: --y is deprecated. Consider -y or --yes");
+		options.yes = true;
+	}
+	const config = await getConfig({
+		cwd,
+		configPath: options.config
+	});
+	if (!config) exitWithError("No configuration file found. Add an `auth.ts` file to your project or pass the path to the configuration file using the `--config` flag.");
+	if (!config.database) exitWithError("No database is configured. Add a persistent database before creating an admin user.");
+	const auth = betterAuth(config);
+	const createUser = auth.api.createUser;
+	if (typeof createUser !== "function") exitWithError("The admin plugin is required. Add `admin()` to your Better Auth plugins before running this command.");
+	const { email, password } = await resolveRequiredInput(options);
+	if (!z.email().safeParse(email).success) exitWithError("Invalid email address.");
+	const data = {
+		...parseData(options.data),
+		emailVerified: options.emailVerified
+	};
 	try {
-		const stripped = fs.readFileSync(tsconfigPath, "utf-8").replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g) => g ? "" : m).replace(/,(?=\s*[}\]])/g, "");
-		return JSON.parse(stripped).references;
-	} catch {
-		return;
+		const totalUsers = await (await auth.$context).internalAdapter.countTotalUsers();
+		if (totalUsers > 0 && !options.force && !options.yes) {
+			if (!(await prompts({
+				type: "confirm",
+				name: "confirmed",
+				message: `Found ${totalUsers} existing user${totalUsers === 1 ? "" : "s"}. Create an admin user anyway?`,
+				initial: false
+			})).confirmed) {
+				console.log("Create admin cancelled.");
+				process.exit(0);
+				return;
+			}
+		}
+	} catch (error) {
+		exitWithError(`Failed to inspect existing users. Make sure your database is reachable and your Better Auth schema is migrated before running this command.${error instanceof Error ? `\n${error.message}` : ""}`);
+	}
+	try {
+		const result = await createUser({ body: {
+			email,
+			password,
+			name: options.name,
+			role: options.role,
+			data
+		} });
+		console.log(chalk.green("Admin user created successfully."));
+		if (result.user?.id) console.log(`User ID: ${result.user.id}`);
+		console.log(`Email: ${result.user?.email ?? email.toLowerCase()}`);
+		console.log(`Role: ${result.user?.role ?? options.role}`);
+		process.exit(0);
+	} catch (error) {
+		if (error instanceof APIError) exitWithError(error.message);
+		if (error instanceof Error) exitWithError(error.message);
+		exitWithError("Failed to create admin user.");
 	}
 }
-/** Recursively collects tsconfigs reachable via `references`. */
-function collectReferencedTsconfigs(tsconfigPath, visited = /* @__PURE__ */ new Set()) {
-	const result = [];
-	const refs = readRawTsconfigReferences(tsconfigPath);
-	if (!refs) return result;
-	const configDir = path.dirname(tsconfigPath);
-	for (const ref of refs) {
-		const resolvedRef = path.resolve(configDir, ref.path);
-		const refTsconfigPath = resolvedRef.endsWith(".json") ? resolvedRef : path.join(resolvedRef, "tsconfig.json");
-		if (visited.has(refTsconfigPath)) continue;
-		visited.add(refTsconfigPath);
-		try {
-			const refConfig = parseTsconfig(refTsconfigPath);
-			result.push({
-				path: refTsconfigPath,
-				config: refConfig
+const createAdmin = new Command("create-admin").description("Create an initial admin user").option("-c, --cwd <cwd>", "the working directory. defaults to the current directory.", process.cwd()).option("--config <config>", "the path to the configuration file. defaults to the first configuration file found.").option("--email <email>", "the email address for the admin user").option("--password <password>", "the password for the admin user").option("--name <name>", "the name for the admin user", "Admin").option("--role <role>", "the role to assign to the user", "admin").option("--data <json>", "additional user fields as a JSON object").option("--no-email-verified", "create the admin user with an unverified email").option("--force", "create an admin user even when users already exist", false).option("-y, --yes", "automatically confirm creating an admin when users already exist", false).option("--y", "(deprecated) same as --yes", false).action(createAdminAction);
+//#endregion
+//#region src/generators/drizzle.ts
+function convertToSnakeCase(str, camelCase) {
+	return camelCase ? str : toSnakeCase(str);
+}
+const generateDrizzleSchema = async ({ options, file, adapter }) => {
+	const tables = getAuthTables(options);
+	const filePath = file || "./auth-schema.ts";
+	const databaseType = adapter.options?.provider;
+	if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
+	const fileExist = existsSync(filePath);
+	let code = generateImport({
+		databaseType,
+		tables,
+		options
+	});
+	const getModelName = initGetModelName({
+		schema: tables,
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
+	const getSingularModelName = initGetModelName({
+		schema: tables,
+		usePlural: false
+	});
+	const getFieldName = initGetFieldName({
+		schema: tables,
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
+	const isMigrationDisabled = (model) => Object.entries(tables).some(([tableKey, table]) => {
+		if (table.disableMigrations !== true) return false;
+		const customModelName = table.modelName || tableKey;
+		return model === tableKey || model === customModelName || model === getModelName(tableKey) || model === getModelName(customModelName);
+	});
+	for (const tableKey in tables) {
+		const table = tables[tableKey];
+		if (isMigrationDisabled(tableKey)) continue;
+		const modelName = getModelName(tableKey);
+		const fields = table.fields;
+		function getType(name, field) {
+			if (!databaseType) throw new Error(`Database provider type is undefined during Drizzle schema generation. Please define a \`provider\` in the Drizzle adapter config. Read more at https://better-auth.com/docs/adapters/drizzle`);
+			name = convertToSnakeCase(name, adapter.options?.camelCase);
+			if (field.references?.field === "id") {
+				const useNumberId = options.advanced?.database?.generateId === "serial";
+				const useUUIDs = options.advanced?.database?.generateId === "uuid";
+				if (useNumberId) if (databaseType === "pg") return `integer('${name}')`;
+				else if (databaseType === "mysql") return `int('${name}')`;
+				else return `integer('${name}')`;
+				if (useUUIDs && databaseType === "pg") return `uuid('${name}')`;
+				if (field.references.field) {
+					if (databaseType === "mysql") return `varchar('${name}', { length: 36 })`;
+				}
+				return `text('${name}')`;
+			}
+			const type = field.type;
+			if (typeof type !== "string") if (Array.isArray(type) && type.every((x) => typeof x === "string")) return {
+				sqlite: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				pg: `text('${name}', { enum: [${type.map((x) => `'${x}'`).join(", ")}] })`,
+				mysql: `mysqlEnum('${name}', [${type.map((x) => `'${x}'`).join(", ")}])`
+			}[databaseType];
+			else throw new TypeError(`Invalid field type for field ${name} in model ${modelName}`);
+			const dbTypeMap = {
+				string: {
+					sqlite: `text('${name}')`,
+					pg: `text('${name}')`,
+					mysql: field.unique ? `varchar('${name}', { length: 255 })` : field.references ? `varchar('${name}', { length: 36 })` : field.sortable ? `varchar('${name}', { length: 255 })` : field.index ? `varchar('${name}', { length: 255 })` : `text('${name}')`
+				},
+				boolean: {
+					sqlite: `integer('${name}', { mode: 'boolean' })`,
+					pg: `boolean('${name}')`,
+					mysql: `boolean('${name}')`
+				},
+				number: {
+					sqlite: `integer('${name}')`,
+					pg: field.bigint ? `bigint('${name}', { mode: 'number' })` : `integer('${name}')`,
+					mysql: field.bigint ? `bigint('${name}', { mode: 'number' })` : `int('${name}')`
+				},
+				date: {
+					sqlite: `integer('${name}', { mode: 'timestamp_ms' })`,
+					pg: `timestamp('${name}')`,
+					mysql: `timestamp('${name}', { fsp: 3 })`
+				},
+				"number[]": {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: field.bigint ? `bigint('${name}', { mode: 'number' }).array()` : `integer('${name}').array()`,
+					mysql: `text('${name}', { mode: 'json' })`
+				},
+				"string[]": {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: `text('${name}').array()`,
+					mysql: `text('${name}', { mode: "json" })`
+				},
+				json: {
+					sqlite: `text('${name}', { mode: "json" })`,
+					pg: `jsonb('${name}')`,
+					mysql: `json('${name}', { mode: "json" })`
+				}
+			}[type];
+			if (!dbTypeMap) throw new Error(`Unsupported field type '${field.type}' for field '${name}'.`);
+			return dbTypeMap[databaseType];
+		}
+		let id = "";
+		const useNumberId = options.advanced?.database?.generateId === "serial";
+		if (options.advanced?.database?.generateId === "uuid" && databaseType === "pg") id = `uuid("id").default(sql\`pg_catalog.gen_random_uuid()\`).primaryKey()`;
+		else if (useNumberId) if (databaseType === "pg") id = `integer("id").generatedByDefaultAsIdentity().primaryKey()`;
+		else if (databaseType === "sqlite") id = `integer("id", { mode: "number" }).primaryKey({ autoIncrement: true })`;
+		else id = `int("id").autoincrement().primaryKey()`;
+		else if (databaseType === "mysql") id = `varchar('id', { length: 36 }).primaryKey()`;
+		else if (databaseType === "pg") id = `text('id').primaryKey()`;
+		else id = `text('id').primaryKey()`;
+		const indexes = [];
+		const assignIndexes = (indexes) => {
+			if (!indexes.length) return "";
+			const code = [`, (table) => [`];
+			for (const index of indexes) code.push(`  ${index.type}("${index.name}").on(table.${index.on}),`);
+			code.push(`]`);
+			return code.join("\n");
+		};
+		const schema = `export const ${modelName} = ${databaseType}Table("${convertToSnakeCase(modelName, adapter.options?.camelCase)}", {
+					id: ${id},
+					${Object.keys(fields).map((field) => {
+			const attr = fields[field];
+			const fieldName = attr.fieldName || field;
+			let type = getType(fieldName, attr);
+			if (attr.index && !attr.unique) indexes.push({
+				type: "index",
+				name: `${modelName}_${fieldName}_idx`,
+				on: fieldName
+			});
+			else if (attr.index && attr.unique) indexes.push({
+				type: "uniqueIndex",
+				name: `${modelName}_${fieldName}_uidx`,
+				on: fieldName
+			});
+			if (attr.defaultValue !== null && typeof attr.defaultValue !== "undefined") if (typeof attr.defaultValue === "function") {
+				if (attr.type === "date" && attr.defaultValue.toString().includes("new Date()")) if (databaseType === "sqlite") type += `.default(sql\`(cast(unixepoch('subsecond') * 1000 as integer))\`)`;
+				else type += `.defaultNow()`;
+			} else if (typeof attr.defaultValue === "string") type += `.default("${attr.defaultValue}")`;
+			else if (Array.isArray(attr.defaultValue)) {
+				const elements = attr.defaultValue.map((value) => JSON.stringify(value)).join(", ");
+				type += `.default([${elements}])`;
+			} else if (typeof attr.defaultValue === "object" && attr.defaultValue !== null) type += `.default(${JSON.stringify(attr.defaultValue)})`;
+			else type += `.default(${attr.defaultValue})`;
+			if (attr.onUpdate && attr.type === "date") {
+				if (typeof attr.onUpdate === "function") type += `.$onUpdate(${attr.onUpdate})`;
+			}
+			const referencesDisabledModel = attr.references && isMigrationDisabled(attr.references.model);
+			return `${fieldName}: ${type}${attr.required !== false ? ".notNull()" : ""}${attr.unique ? ".unique()" : ""}${attr.references && !referencesDisabledModel ? `.references(()=> ${getModelName(attr.references.model)}.${getFieldName({
+				model: attr.references.model,
+				field: attr.references.field
+			})}, { onDelete: '${attr.references.onDelete || "cascade"}' })` : ""}`;
+		}).join(",\n ")}
+					}${assignIndexes(indexes)});`;
+		code += `\n${schema}\n`;
+	}
+	let relationsString = "";
+	for (const tableKey in tables) {
+		const table = tables[tableKey];
+		if (isMigrationDisabled(tableKey)) continue;
+		const modelName = getModelName(tableKey);
+		const oneRelations = [];
+		const manyRelations = [];
+		const manyRelationsSet = /* @__PURE__ */ new Set();
+		const foreignFields = Object.entries(table.fields).filter(([_, field]) => field.references);
+		for (const [fieldName, field] of foreignFields) {
+			const referencedModel = field.references.model;
+			if (isMigrationDisabled(referencedModel)) continue;
+			const relationKey = getSingularModelName(referencedModel);
+			const fieldRef = `${getModelName(tableKey)}.${getFieldName({
+				model: tableKey,
+				field: fieldName
+			})}`;
+			const referenceRef = `${getModelName(referencedModel)}.${getFieldName({
+				model: referencedModel,
+				field: field.references.field || "id"
+			})}`;
+			oneRelations.push({
+				key: relationKey,
+				model: getModelName(referencedModel),
+				type: "one",
+				reference: {
+					field: fieldRef,
+					references: referenceRef,
+					fieldName
+				}
 			});
-		} catch {
-			continue;
 		}
-		result.push(...collectReferencedTsconfigs(refTsconfigPath, visited));
+		const otherModels = Object.entries(tables).filter(([modelName, otherTable]) => modelName !== tableKey && !otherTable.disableMigrations);
+		const modelRelationsMap = /* @__PURE__ */ new Map();
+		for (const [modelName, otherTable] of otherModels) {
+			const foreignKeysPointingHere = Object.entries(otherTable.fields).filter(([_, field]) => field.references?.model === tableKey || field.references?.model === getModelName(tableKey));
+			if (foreignKeysPointingHere.length === 0) continue;
+			const hasUnique = foreignKeysPointingHere.some(([_, field]) => !!field.unique);
+			const hasMany = foreignKeysPointingHere.some(([_, field]) => !field.unique);
+			modelRelationsMap.set(modelName, {
+				modelName,
+				hasUnique,
+				hasMany
+			});
+		}
+		for (const { modelName, hasMany } of modelRelationsMap.values()) {
+			const relationType = hasMany ? "many" : "one";
+			let relationKey = getModelName(modelName);
+			if (!adapter.options?.adapterConfig?.usePlural && relationType === "many") relationKey = `${relationKey}s`;
+			if (!manyRelationsSet.has(relationKey)) {
+				manyRelationsSet.add(relationKey);
+				manyRelations.push({
+					key: relationKey,
+					model: getModelName(modelName),
+					type: relationType
+				});
+			}
+		}
+		const relationsByModel = /* @__PURE__ */ new Map();
+		for (const relation of oneRelations) if (relation.reference) {
+			const modelKey = relation.key;
+			if (!relationsByModel.has(modelKey)) relationsByModel.set(modelKey, []);
+			relationsByModel.get(modelKey).push(relation);
+		}
+		const duplicateRelations = [];
+		const singleRelations = [];
+		for (const [_modelKey, relations] of relationsByModel.entries()) if (relations.length > 1) duplicateRelations.push(...relations);
+		else singleRelations.push(relations[0]);
+		for (const relation of duplicateRelations) if (relation.reference) {
+			const fieldName = relation.reference.fieldName;
+			const tableRelation = `export const ${`${modelName}${fieldName.charAt(0).toUpperCase() + fieldName.slice(1)}Relations`} = relations(${getModelName(table.modelName)}, ({ one }) => ({
+				${relation.key}: one(${relation.model}, {
+					fields: [${relation.reference.field}],
+					references: [${relation.reference.references}],
+				})
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		}
+		const hasOne = singleRelations.length > 0;
+		const hasMany = manyRelations.length > 0;
+		if (hasOne && hasMany) {
+			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one, many }) => ({
+				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
+					fields: [${relation.reference.field}],
+					references: [${relation.reference.references}],
+				})` : "").filter((x) => x !== "").join(",\n ")}${singleRelations.length > 0 && manyRelations.length > 0 ? "," : ""}
+				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		} else if (hasOne) {
+			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ one }) => ({
+				${singleRelations.map((relation) => relation.reference ? ` ${relation.key}: one(${relation.model}, {
+					fields: [${relation.reference.field}],
+					references: [${relation.reference.references}],
+				})` : "").filter((x) => x !== "").join(",\n ")}
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		} else if (hasMany) {
+			const tableRelation = `export const ${modelName}Relations = relations(${getModelName(table.modelName)}, ({ many }) => ({
+				${manyRelations.map(({ key, model }) => ` ${key}: many(${model})`).join(",\n ")}
+			}))`;
+			relationsString += `\n${tableRelation}\n`;
+		}
 	}
-	return result;
+	code += `\n${relationsString}`;
+	return {
+		code: await prettier.format(code, { parser: "typescript" }),
+		fileName: filePath,
+		overwrite: fileExist
+	};
+};
+function generateImport({ databaseType, tables, options }) {
+	const rootImports = ["relations"];
+	const coreImports = [];
+	let hasBigint = false;
+	let hasJson = false;
+	for (const table of Object.values(tables)) {
+		for (const field of Object.values(table.fields)) {
+			if (field.bigint) hasBigint = true;
+			if (field.type === "json") hasJson = true;
+		}
+		if (hasJson && hasBigint) break;
+	}
+	const useNumberId = options.advanced?.database?.generateId === "serial";
+	const useUUIDs = options.advanced?.database?.generateId === "uuid";
+	coreImports.push(`${databaseType}Table`);
+	coreImports.push(databaseType === "mysql" ? "varchar, text" : databaseType === "pg" ? "text" : "text");
+	coreImports.push(hasBigint ? databaseType !== "sqlite" ? "bigint" : "" : "");
+	coreImports.push(databaseType !== "sqlite" ? "timestamp, boolean" : "");
+	if (databaseType === "mysql") {
+		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
+		if (useNumberId || hasNonBigintNumber) coreImports.push("int");
+		if (Object.values(tables).some((table) => Object.values(table.fields).some((field) => typeof field.type !== "string" && Array.isArray(field.type) && field.type.every((x) => typeof x === "string")))) coreImports.push("mysqlEnum");
+	} else if (databaseType === "pg") {
+		if (useUUIDs) rootImports.push("sql");
+		const hasNonBigintNumber = Object.values(tables).some((table) => Object.values(table.fields).some((field) => (field.type === "number" || field.type === "number[]") && !field.bigint));
+		const hasFkToId = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.references?.field === "id"));
+		if (hasNonBigintNumber || options.advanced?.database?.generateId === "serial" && hasFkToId) coreImports.push("integer");
+	} else coreImports.push("integer");
+	if (databaseType === "pg" && useUUIDs) coreImports.push("uuid");
+	if (hasJson) {
+		if (databaseType === "pg") coreImports.push("jsonb");
+		if (databaseType === "mysql") coreImports.push("json");
+	}
+	if (databaseType === "sqlite" && Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.type === "date" && field.defaultValue && typeof field.defaultValue === "function" && field.defaultValue.toString().includes("new Date()")))) rootImports.push("sql");
+	const hasIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.index && !field.unique));
+	const hasUniqueIndexes = Object.values(tables).some((table) => Object.values(table.fields).some((field) => field.unique && field.index));
+	if (hasIndexes) coreImports.push("index");
+	if (hasUniqueIndexes) coreImports.push("uniqueIndex");
+	return `${rootImports.length > 0 ? `import { ${rootImports.join(", ")} } from "drizzle-orm";\n` : ""}import { ${coreImports.map((x) => x.trim()).filter((x) => x !== "").join(", ")} } from "drizzle-orm/${databaseType}-core";\n`;
 }
-/**
-* Ordered `paths` matchers from the project tsconfig and any referenced
-* tsconfigs, following TypeScript canonical resolution semantics.
-* @see https://github.com/microsoft/TypeScript/blob/main/src/compiler/moduleNameResolver.ts
-*/
-function collectPathsMatchers(cwd) {
-	const tsconfig = getTsconfig(cwd, fs.existsSync(path.join(cwd, "tsconfig.json")) ? "tsconfig.json" : "jsconfig.json");
-	if (!tsconfig) return [];
-	const matchers = [];
+//#endregion
+//#region src/generators/kysely.ts
+const generateKyselySchema = async ({ options, file }) => {
+	const { compileMigrations } = await getMigrations(options);
+	const migrations = await compileMigrations();
+	return {
+		code: migrations.trim() === ";" ? "" : migrations,
+		fileName: file || `./better-auth_migrations/${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}.sql`
+	};
+};
+//#endregion
+//#region src/utils/helper.ts
+async function tryCatch(promise) {
 	try {
-		const mainMatcher = createPathsMatcher(tsconfig);
-		if (mainMatcher) matchers.push(mainMatcher);
-		for (const refTsconfig of collectReferencedTsconfigs(tsconfig.path)) {
-			const refMatcher = createPathsMatcher(refTsconfig);
-			if (refMatcher) matchers.push(refMatcher);
-		}
+		return {
+			data: await promise,
+			error: null
+		};
 	} catch (error) {
-		console.error(error);
-		throw new BetterAuthError("Error parsing tsconfig.json");
+		return {
+			data: null,
+			error
+		};
 	}
-	return matchers;
 }
-/**
-* Source file extensions jiti can load. Shared between the jiti `extensions`
-* option and `resolveCandidateFile` so both stay in sync.
-*/
-const SOURCE_EXTENSIONS = [
-	".ts",
-	".tsx",
-	".mts",
-	".cts",
-	".js",
-	".jsx",
-	".mjs",
-	".cjs"
-];
-const SOURCE_EXTENSIONS_SET = new Set(SOURCE_EXTENSIONS);
-/** Probes a candidate as-is, with known extensions, and as a directory index. */
-function resolveCandidateFile(candidate) {
-	try {
-		if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) return candidate;
-	} catch {}
-	if (SOURCE_EXTENSIONS_SET.has(path.extname(candidate))) return;
-	for (const ext of SOURCE_EXTENSIONS) {
-		const withExt = candidate + ext;
-		if (fs.existsSync(withExt)) return withExt;
-	}
-	for (const ext of SOURCE_EXTENSIONS) {
-		const asIndex = path.join(candidate, `index${ext}`);
-		if (fs.existsSync(asIndex)) return asIndex;
-	}
+const generateSecretHash = () => {
+	return Crypto.randomBytes(32).toString("hex");
+};
+const spawnCommand = (cmd, cwd = process.cwd()) => new Promise((resolve, reject) => {
+	const child = spawn(cmd, {
+		cwd,
+		stdio: "inherit",
+		shell: true
+	});
+	child.on("close", (code, signal) => {
+		if (code !== 0 && code !== null) reject(/* @__PURE__ */ new Error(`Exited with code ${code}`));
+		else if (signal) reject(/* @__PURE__ */ new Error(`Killed with signal ${signal}`));
+		else resolve();
+	});
+	child.on("error", reject);
+});
+//#endregion
+//#region src/utils/get-package-info.ts
+function getPackageInfo(cwd) {
+	const packageJsonPath = cwd ? path.join(cwd, "package.json") : path.join("package.json");
+	return JSON.parse(readFileSync(packageJsonPath, "utf-8"));
 }
-function resolveWithMatchers(specifier, matchers) {
-	for (const matcher of matchers) for (const candidate of matcher(specifier)) {
-		const resolved = resolveCandidateFile(candidate);
-		if (resolved) return resolved;
+function getPrismaVersion(cwd) {
+	try {
+		const packageInfo = getPackageInfo(cwd);
+		const prismaVersion = packageInfo.dependencies?.prisma || packageInfo.devDependencies?.prisma || packageInfo.dependencies?.["@prisma/client"] || packageInfo.devDependencies?.["@prisma/client"];
+		if (!prismaVersion) return null;
+		const match = prismaVersion.match(/(\d+)/);
+		return match ? parseInt(match[1], 10) : null;
+	} catch {
+		return null;
 	}
 }
 /**
-* Callees whose first string argument is a module specifier. `jitiImport` is
-* a jiti-side preprocessor artifact observed in the AST; revisit on jiti
-* major version bumps (the regression suite catches a rename but not the why).
+* Checks if a package has a specific dependency.
+*
+* @param packageJson The package.json object
+* @param dependency The dependency to check for
+* @returns true if the package has the dependency
 */
-const LOADER_IDENTIFIERS = new Set([
-	"require",
-	"import",
-	"jitiImport"
-]);
+function hasDependency(packageJson, dependency) {
+	let hasDependency = false;
+	if (packageJson.dependencies?.[dependency] || packageJson.devDependencies?.[dependency] || packageJson.peerDependencies?.[dependency] || packageJson.optionalDependencies?.[dependency]) hasDependency = true;
+	return hasDependency;
+}
 /**
-* Rewrites aliased specifiers at AST level. Required because jiti's `alias`
-* option only supports prefix matching and cannot express mid-path wildcards.
+* Checks if a directory is a monorepo root by looking for common monorepo indicators.
 *
-* Matchers always take precedence over native resolution, mirroring
-* TypeScript's own `paths` → `node_modules` order.
+* @param dir Directory to check
+* @returns true if the directory appears to be a monorepo root
 */
-function createRewriteImportPathsPlugin(matchers) {
-	return ({ types: t }) => {
-		const rewrite = (source) => {
-			if (!source) return;
-			const resolved = resolveWithMatchers(source.value, matchers);
-			if (resolved) source.value = resolved;
-		};
-		return { visitor: {
-			ImportDeclaration(p) {
-				rewrite(p.node.source);
-			},
-			ExportNamedDeclaration(p) {
-				rewrite(p.node.source);
-			},
-			ExportAllDeclaration(p) {
-				rewrite(p.node.source);
-			},
-			ImportExpression(p) {
-				if (t.isStringLiteral(p.node.source)) rewrite(p.node.source);
-			},
-			CallExpression(p) {
-				const { callee, arguments: args } = p.node;
-				const first = args[0];
-				if (!t.isStringLiteral(first)) return;
-				if (!(t.isIdentifier(callee) && LOADER_IDENTIFIERS.has(callee.name) || t.isImport(callee))) return;
-				rewrite(first);
-			}
-		} };
-	};
-}
-/** Virtual module aliases; real tsconfig paths go through the babel plugin. */
-function getVirtualModuleAliases() {
-	const result = {};
-	addSvelteKitEnvModules(result);
-	addCloudflareModules(result);
-	return result;
+async function isMonorepoRoot(dir) {
+	const { data: files } = await tryCatch(fs$1.readdir(dir, "utf-8"));
+	if (!files) return false;
+	if (files.includes("pnpm-workspace.yaml")) return true;
+	if (files.includes("package.json")) {
+		const packageJsonPath = path.join(dir, "package.json");
+		const { data } = await tryCatch(fs$1.readFile(packageJsonPath, "utf-8"));
+		if (data) try {
+			const packageJson = JSON.parse(data);
+			if (packageJson.workspaces && (Array.isArray(packageJson.workspaces) || typeof packageJson.workspaces === "object")) return true;
+		} catch {}
+	}
+	return [
+		"lerna.json",
+		"turbo.json",
+		"nx.json",
+		"rush.json"
+	].some((indicator) => files.includes(indicator));
 }
 /**
-* .tsx files are not supported by Jiti.
+* Finds the monorepo root by walking up the directory tree.
+*
+* @param startDir Starting directory
+* @returns Path to monorepo root, or null if not found
 */
-const jitiOptions = (cwd) => {
-	const matchers = collectPathsMatchers(cwd);
-	const plugins = matchers.length > 0 ? [createRewriteImportPathsPlugin(matchers)] : [];
-	return {
-		transformOptions: { babel: {
-			presets: [[babelPresetTypeScript, {
-				isTSX: true,
-				allExtensions: true
-			}], [babelPresetReact, { runtime: "automatic" }]],
-			plugins
-		} },
-		extensions: [...SOURCE_EXTENSIONS],
-		alias: getVirtualModuleAliases()
-	};
-};
-const isDefaultExport = (object) => {
-	return typeof object === "object" && object !== null && !Array.isArray(object) && Object.keys(object).length > 0 && "options" in object;
-};
-async function getConfig({ cwd, configPath, shouldThrowOnError = false }) {
-	try {
-		let configFile = null;
-		if (configPath) {
-			let resolvedPath = path.join(cwd, configPath);
-			if (existsSync(configPath)) resolvedPath = configPath;
-			const { config } = await loadConfig({
-				configFile: resolvedPath,
-				dotenv: { fileName: [".env", ".env.local"] },
-				jitiOptions: jitiOptions(cwd),
-				cwd
-			});
-			if (!("auth" in config) && !isDefaultExport(config)) {
-				if (shouldThrowOnError) throw new Error(`Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`);
-				console.error(`[#better-auth]: Couldn't read your auth config in ${resolvedPath}. Make sure to default export your auth instance or to export as a variable named auth.`);
-				process.exit(1);
+async function findMonorepoRoot(startDir) {
+	let currentDir = path.resolve(startDir);
+	const root = path.parse(currentDir).root;
+	while (currentDir !== root) {
+		if (await isMonorepoRoot(currentDir)) return currentDir;
+		const parentDir = path.dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+	return null;
+}
+//#endregion
+//#region src/generators/prisma.ts
+const generatePrismaSchema = async ({ adapter, options, file }) => {
+	const provider = adapter.options?.provider || "postgresql";
+	const tables = getAuthTables(options);
+	const filePath = file || "./prisma/schema.prisma";
+	const schemaPrismaExist = existsSync(path.join(process.cwd(), filePath));
+	const getModelName = initGetModelName({
+		schema: getAuthTables(options),
+		usePlural: adapter.options?.adapterConfig?.usePlural
+	});
+	const getFieldName = initGetFieldName({
+		schema: getAuthTables(options),
+		usePlural: false
+	});
+	const isMigrationDisabled = (model) => Object.entries(tables).some(([tableKey, table]) => {
+		if (table.disableMigrations !== true) return false;
+		const customModelName = table.modelName || tableKey;
+		return model === tableKey || model === customModelName || model === getModelName(tableKey) || model === getModelName(customModelName);
+	});
+	let schemaPrisma = "";
+	if (schemaPrismaExist) schemaPrisma = await fs$1.readFile(path.join(process.cwd(), filePath), "utf-8");
+	else schemaPrisma = getNewPrisma(provider, process.cwd());
+	const prismaVersion = getPrismaVersion(process.cwd());
+	if (prismaVersion && prismaVersion >= 7 && schemaPrismaExist) schemaPrisma = produceSchema(schemaPrisma, (builder) => {
+		const generator = builder.findByType("generator", { name: "client" });
+		if (generator && generator.properties) {
+			const providerProp = generator.properties.find((prop) => prop.type === "assignment" && prop.key === "provider");
+			if (providerProp && providerProp.value === "\"prisma-client-js\"") providerProp.value = "\"prisma-client\"";
+		}
+		const datasource = builder.findByType("datasource", { name: "db" });
+		if (datasource && datasource.properties) {
+			const urlIndex = datasource.properties.findIndex((prop) => prop.type === "assignment" && prop.key === "url");
+			if (urlIndex !== -1) datasource.properties.splice(urlIndex, 1);
+		}
+	});
+	const manyToManyRelations = /* @__PURE__ */ new Map();
+	for (const table in tables) {
+		if (isMigrationDisabled(table)) continue;
+		const fields = tables[table]?.fields;
+		for (const field in fields) {
+			const attr = fields[field];
+			if (attr.references) {
+				const referencedOriginalModel = attr.references.model;
+				if (isMigrationDisabled(referencedOriginalModel)) continue;
+				const referencedModelNameCap = capitalizeFirstLetter(getModelName(tables[referencedOriginalModel]?.modelName || referencedOriginalModel));
+				if (!manyToManyRelations.has(referencedModelNameCap)) manyToManyRelations.set(referencedModelNameCap, /* @__PURE__ */ new Set());
+				const currentModelNameCap = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
+				manyToManyRelations.get(referencedModelNameCap).add(currentModelNameCap);
 			}
-			configFile = "auth" in config ? config.auth?.options : config.options;
 		}
-		if (!configFile) for (const possiblePath of possiblePaths$1) try {
-			const { config } = await loadConfig({
-				configFile: possiblePath,
-				dotenv: { fileName: [".env", ".env.local"] },
-				jitiOptions: jitiOptions(cwd),
-				cwd
-			});
-			if (Object.keys(config).length > 0) {
-				configFile = config.auth?.options || config.default?.options || null;
-				if (!configFile) {
-					if (shouldThrowOnError) throw new Error("Couldn't read your auth config. Make sure to default export your auth instance or to export as a variable named auth.");
-					console.error("[#better-auth]: Couldn't read your auth config.");
-					console.log("");
-					console.log("[#better-auth]: Make sure to default export your auth instance or to export as a variable named auth.");
-					process.exit(1);
+	}
+	const indexedFields = /* @__PURE__ */ new Map();
+	for (const table in tables) {
+		const fields = tables[table]?.fields;
+		const modelName = capitalizeFirstLetter(getModelName(tables[table]?.modelName || table));
+		indexedFields.set(modelName, []);
+		for (const field in fields) {
+			const attr = fields[field];
+			if (attr.index && !attr.unique) {
+				const fieldName = attr.fieldName || field;
+				indexedFields.get(modelName).push(fieldName);
+			}
+		}
+	}
+	const schema = produceSchema(schemaPrisma, (builder) => {
+		for (const table in tables) {
+			if (isMigrationDisabled(table)) continue;
+			const originalTableName = table;
+			const customModelName = tables[table]?.modelName || table;
+			const modelName = capitalizeFirstLetter(getModelName(customModelName));
+			const fields = tables[table]?.fields;
+			function getType({ isBigint, isOptional, type }) {
+				if (type === "string") return isOptional ? "String?" : "String";
+				if (type === "number" && isBigint) return isOptional ? "BigInt?" : "BigInt";
+				if (type === "number") return isOptional ? "Int?" : "Int";
+				if (type === "boolean") return isOptional ? "Boolean?" : "Boolean";
+				if (type === "date") return isOptional ? "DateTime?" : "DateTime";
+				if (type === "json") {
+					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
+					return isOptional ? "Json?" : "Json";
+				}
+				if (type === "string[]") {
+					if (provider === "sqlite" || provider === "mysql") return isOptional ? "String?" : "String";
+					return "String[]";
+				}
+				if (type === "number[]") {
+					if (provider === "sqlite" || provider === "mysql") return "String";
+					return "Int[]";
 				}
-				break;
 			}
-		} catch (e) {
-			if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module")) {
-				if (shouldThrowOnError) throw new Error(`Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`);
-				console.error(`Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`);
-				process.exit(1);
+			function getFieldTypeParts(type) {
+				const isArray = type.endsWith("[]");
+				const typeWithoutArray = isArray ? type.slice(0, -2) : type;
+				const isOptional = typeWithoutArray.endsWith("?");
+				return {
+					fieldType: isOptional ? typeWithoutArray.slice(0, -1) : typeWithoutArray,
+					isArray,
+					isOptional
+				};
 			}
-			if (shouldThrowOnError) throw e;
-			console.error("[#better-auth]: Couldn't read your auth config.", e);
-			process.exit(1);
-		}
-		return configFile;
-	} catch (e) {
-		if (typeof e === "object" && e && "message" in e && typeof e.message === "string" && e.message.includes("This module cannot be imported from a Client Component module")) {
-			if (shouldThrowOnError) throw new Error(`Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`);
-			console.error(`Please remove import 'server-only' from your auth config file temporarily. The CLI cannot resolve the configuration with it included. You can re-add it after running the CLI.`);
-			process.exit(1);
+			const prismaModel = builder.findByType("model", { name: modelName });
+			if (!prismaModel) if (provider === "mongodb") builder.model(modelName).field("id", "String").attribute("id").attribute(`map("_id")`);
+			else {
+				const useNumberId = options.advanced?.database?.generateId === "serial";
+				const useUUIDs = options.advanced?.database?.generateId === "uuid";
+				if (useNumberId) builder.model(modelName).field("id", "Int").attribute("id").attribute("default(autoincrement())");
+				else if (useUUIDs && provider === "postgresql") builder.model(modelName).field("id", "String").attribute("id").attribute("default(dbgenerated(\"pg_catalog.gen_random_uuid()\"))").attribute("db.Uuid");
+				else builder.model(modelName).field("id", "String").attribute("id");
+			}
+			for (const field in fields) {
+				const attr = fields[field];
+				const fieldName = attr.fieldName || field;
+				const useUUIDs = options.advanced?.database?.generateId === "uuid";
+				const useNumberId = options.advanced?.database?.generateId === "serial";
+				const fieldType = field === "id" && useNumberId ? getType({
+					isBigint: false,
+					isOptional: false,
+					type: "number"
+				}) : getType({
+					isBigint: attr?.bigint || false,
+					isOptional: attr?.required === false,
+					type: attr.references?.field === "id" ? useNumberId ? "number" : "string" : attr.type
+				});
+				if (prismaModel) {
+					const isAlreadyExist = builder.findByType("field", {
+						name: fieldName,
+						within: prismaModel.properties
+					});
+					if (isAlreadyExist) {
+						if (fieldType && typeof isAlreadyExist.fieldType === "string") {
+							const fieldTypeParts = getFieldTypeParts(fieldType);
+							const existingFieldTypeParts = getFieldTypeParts(isAlreadyExist.fieldType);
+							if ((existingFieldTypeParts.fieldType === "Int" || existingFieldTypeParts.fieldType === "BigInt") && (fieldTypeParts.fieldType === "Int" || fieldTypeParts.fieldType === "BigInt")) {
+								isAlreadyExist.fieldType = fieldTypeParts.fieldType;
+								isAlreadyExist.optional = fieldTypeParts.isOptional || void 0;
+								isAlreadyExist.array = fieldTypeParts.isArray || void 0;
+							}
+						}
+						continue;
+					}
+				}
+				if (!fieldType) throw new Error(`Unsupported Prisma field type for model "${modelName}", field "${fieldName}"${attr.type ? ` (source type: "${attr.type}")` : ""}.`);
+				const fieldBuilder = builder.model(modelName).field(fieldName, fieldType);
+				if (field === "id") {
+					fieldBuilder.attribute("id");
+					if (provider === "mongodb") fieldBuilder.attribute(`map("_id")`);
+				}
+				if (attr.unique) builder.model(modelName).blockAttribute(`unique([${fieldName}])`);
+				if (attr.defaultValue !== void 0) {
+					if (Array.isArray(attr.defaultValue)) {
+						if (attr.type === "json") {
+							if (Object.prototype.toString.call(attr.defaultValue[0]) === "[object Object]") {
+								fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
+								continue;
+							}
+							const jsonArray = [];
+							for (const value of attr.defaultValue) jsonArray.push(value);
+							fieldBuilder.attribute(`default("${JSON.stringify(jsonArray).replace(/"/g, "\\\"")}")`);
+							continue;
+						}
+						if (attr.defaultValue.length === 0) {
+							fieldBuilder.attribute(`default([])`);
+							continue;
+						} else if (typeof attr.defaultValue[0] === "string" && attr.type === "string[]") {
+							const valueArray = [];
+							for (const value of attr.defaultValue) valueArray.push(JSON.stringify(value));
+							fieldBuilder.attribute(`default([${valueArray}])`);
+						} else if (typeof attr.defaultValue[0] === "number") {
+							const valueArray = [];
+							for (const value of attr.defaultValue) valueArray.push(`${value}`);
+							fieldBuilder.attribute(`default([${valueArray}])`);
+						}
+					} else if (typeof attr.defaultValue === "object" && !Array.isArray(attr.defaultValue) && attr.defaultValue !== null) {
+						if (Object.entries(attr.defaultValue).length === 0) {
+							fieldBuilder.attribute(`default("{}")`);
+							continue;
+						}
+						fieldBuilder.attribute(`default("${JSON.stringify(attr.defaultValue).replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}")`);
+					}
+					if (field === "createdAt") fieldBuilder.attribute("default(now())");
+					else if (typeof attr.defaultValue === "string" && provider !== "mysql") fieldBuilder.attribute(`default("${attr.defaultValue}")`);
+					else if (typeof attr.defaultValue === "boolean" || typeof attr.defaultValue === "number") fieldBuilder.attribute(`default(${attr.defaultValue})`);
+					else if (typeof attr.defaultValue === "function") {}
+				}
+				if (field === "updatedAt" && attr.onUpdate) fieldBuilder.attribute("updatedAt");
+				else if (attr.onUpdate) {}
+				if (attr.references) {
+					const referencedOriginalModelName = getModelName(attr.references.model);
+					if (isMigrationDisabled(referencedOriginalModelName) || isMigrationDisabled(attr.references.model)) continue;
+					if (useUUIDs && provider === "postgresql" && attr.references?.field === "id") builder.model(modelName).field(fieldName).attribute(`db.Uuid`);
+					const referencedCustomModelName = tables[referencedOriginalModelName]?.modelName || referencedOriginalModelName;
+					let action = "Cascade";
+					if (attr.references.onDelete === "no action") action = "NoAction";
+					else if (attr.references.onDelete === "set null") action = "SetNull";
+					else if (attr.references.onDelete === "set default") action = "SetDefault";
+					else if (attr.references.onDelete === "restrict") action = "Restrict";
+					const relationField = `relation(fields: [${getFieldName({
+						model: originalTableName,
+						field: fieldName
+					})}], references: [${getFieldName({
+						model: attr.references.model,
+						field: attr.references.field
+					})}], onDelete: ${action})`;
+					builder.model(modelName).field(referencedCustomModelName.toLowerCase(), `${capitalizeFirstLetter(referencedCustomModelName)}${attr.required === false ? "?" : ""}`).attribute(relationField);
+				}
+				if (!attr.unique && !attr.references && provider === "mysql" && attr.type === "string") builder.model(modelName).field(fieldName).attribute("db.Text");
+			}
+			if (manyToManyRelations.has(modelName)) for (const relatedModel of manyToManyRelations.get(modelName)) {
+				const relatedTableName = Object.keys(tables).find((key) => capitalizeFirstLetter(tables[key]?.modelName || key) === relatedModel);
+				const relatedFields = relatedTableName ? tables[relatedTableName]?.fields : {};
+				const [_fieldKey, fkFieldAttr] = Object.entries(relatedFields || {}).find(([_fieldName, fieldAttr]) => fieldAttr.references && getModelName(fieldAttr.references.model) === getModelName(originalTableName)) || [];
+				const isUnique = fkFieldAttr?.unique === true;
+				const fieldName = isUnique || adapter.options?.usePlural === true ? `${relatedModel.toLowerCase()}` : `${relatedModel.toLowerCase()}s`;
+				if (!builder.findByType("field", {
+					name: fieldName,
+					within: prismaModel?.properties
+				})) builder.model(modelName).field(fieldName, `${relatedModel}${isUnique ? "?" : "[]"}`);
+			}
+			const indexedFieldsForModel = indexedFields.get(modelName);
+			if (indexedFieldsForModel && indexedFieldsForModel.length > 0) for (const fieldName of indexedFieldsForModel) {
+				if (prismaModel) {
+					if (prismaModel.properties.some((v) => v.type === "attribute" && v.name === "index" && JSON.stringify(v.args[0]?.value).includes(fieldName))) continue;
+				}
+				const field = Object.entries(fields).find(([key, attr]) => (attr.fieldName || key) === fieldName)?.[1];
+				let indexField = fieldName;
+				if (provider === "mysql" && field && field.type === "string") {
+					const useNumberId = options.advanced?.database?.generateId === "serial";
+					const useUUIDs = options.advanced?.database?.generateId === "uuid";
+					if (field.references?.field === "id" && (useNumberId || useUUIDs)) indexField = `${fieldName}`;
+					else indexField = `${fieldName}(length: 191)`;
+				}
+				builder.model(modelName).blockAttribute(`index([${indexField}])`);
+			}
+			const hasAttribute = builder.findByType("attribute", {
+				name: "map",
+				within: prismaModel?.properties
+			});
+			const hasChanged = customModelName !== originalTableName;
+			if (!hasAttribute) builder.model(modelName).blockAttribute("map", `${getModelName(hasChanged ? customModelName : originalTableName)}`);
 		}
-		if (shouldThrowOnError) throw e;
-		console.error("Couldn't read your auth config.", e);
-		process.exit(1);
-	}
-}
+	});
+	const schemaChanged = schema.trim() !== schemaPrisma.trim();
+	return {
+		code: schemaChanged ? schema : "",
+		fileName: filePath,
+		overwrite: schemaPrismaExist && schemaChanged
+	};
+};
+const getNewPrisma = (provider, cwd) => {
+	const prismaVersion = getPrismaVersion(cwd);
+	const isV7 = prismaVersion && prismaVersion >= 7;
+	const clientProvider = isV7 ? "prisma-client" : "prisma-client-js";
+	if (isV7) return `generator client {
+    provider = "${clientProvider}"
+  }
+
+  datasource db {
+    provider = "${provider}"
+  }`;
+	return `generator client {
+    provider = "${clientProvider}"
+  }
+
+  datasource db {
+    provider = "${provider}"
+    url      = ${provider === "sqlite" ? `"file:./dev.db"` : `env("DATABASE_URL")`}
+  }`;
+};
+//#endregion
+//#region src/generators/index.ts
+const adapters = {
+	prisma: generatePrismaSchema,
+	drizzle: generateDrizzleSchema,
+	kysely: generateKyselySchema
+};
+const generateSchema = async (opts) => {
+	const adapter = opts.adapter;
+	if (adapter.createSchema) return adapter.createSchema(opts.options, opts.file).then(({ code, path: fileName, overwrite }) => ({
+		code,
+		fileName,
+		overwrite
+	}));
+	const generator = adapters[adapter.id] ?? null;
+	if (generator) return await generator(opts);
+	throw new Error(`${adapter.id} is not supported. If it is a custom adapter, please request the maintainer to implement the "createSchema" method on the adapter.`);
+};
 //#endregion
 //#region src/commands/generate.ts
 function createMockAdapter$1(adapterId, dialect) {
@@ -1746,6 +2023,12 @@ function createMockAdapter$1(adapterId, dialect) {
 		deleteMany: async () => {
 			throw new Error("Mock adapter methods should not be called");
 		},
+		consumeOne: async () => {
+			throw new Error("Mock adapter methods should not be called");
+		},
+		incrementOne: async () => {
+			throw new Error("Mock adapter methods should not be called");
+		},
 		transaction: async (callback) => {
 			throw new Error("Mock adapter methods should not be called");
 		},
@@ -1755,6 +2038,19 @@ function createMockAdapter$1(adapterId, dialect) {
 		}
 	};
 }
+function getDefaultSchemaOutputFileName(adapterId, now = /* @__PURE__ */ new Date()) {
+	if (adapterId === "prisma") return "schema.prisma";
+	if (adapterId === "kysely") return `${now.toISOString().replace(/:/g, "-")}.sql`;
+	return "auth-schema.ts";
+}
+async function resolveSchemaOutputPath({ cwd, output, adapterId, now = /* @__PURE__ */ new Date() }) {
+	if (!output) return output;
+	const resolvedOutput = path.resolve(cwd, output);
+	try {
+		if ((await fs$1.stat(resolvedOutput)).isDirectory()) return path.join(output, getDefaultSchemaOutputFileName(adapterId, now));
+	} catch {}
+	return output;
+}
 async function generateAction(opts) {
 	const options = z.object({
 		cwd: z.string(),
@@ -1784,6 +2080,11 @@ async function generateAction(opts) {
 		console.error(e.message);
 		process.exit(1);
 	});
+	options.output = await resolveSchemaOutputPath({
+		cwd,
+		output: options.output,
+		adapterId: adapter.id
+	});
 	const spinner = yoctoSpinner({ text: "preparing schema..." }).start();
 	const schema = await generateSchema({
 		adapter,
@@ -2007,6 +2308,8 @@ function sanitizeBetterAuthConfig(config) {
 	const sanitized = JSON.parse(JSON.stringify(config));
 	const sensitiveKeys = [
 		"secret",
+		"secrets",
+		"secretKey",
 		"clientSecret",
 		"clientId",
 		"authToken",
@@ -2060,6 +2363,7 @@ function sanitizeBetterAuthConfig(config) {
 				const lowerSensitiveKey = sensitiveKey.toLowerCase();
 				return lowerKey === lowerSensitiveKey || lowerKey.endsWith(lowerSensitiveKey);
 			})) if (typeof value === "string" && value.length > 0) result[key] = "[REDACTED]";
+			else if (Array.isArray(value)) result[key] = "[REDACTED]";
 			else if (typeof value === "object" && value !== null) result[key] = redactSensitive(value, key);
 			else result[key] = value;
 			else result[key] = redactSensitive(value, key);
@@ -3528,14 +3832,7 @@ const tempPluginsConfig = {
 				isNamedImport: false
 			}]
 		},
-		authClient: {
-			function: "genericOAuthClient",
-			imports: [{
-				path: "better-auth/client/plugins",
-				imports: [createImport({ name: "genericOAuthClient" })],
-				isNamedImport: false
-			}]
-		}
+		authClient: null
 	},
 	anonymous: {
 		displayName: "Anonymous",
@@ -3594,25 +3891,6 @@ const tempPluginsConfig = {
 			}]
 		}
 	},
-	oidc: {
-		displayName: "OIDC",
-		auth: {
-			function: "oidc",
-			imports: [{
-				path: "better-auth/plugins",
-				imports: [createImport({ name: "oidc" })],
-				isNamedImport: false
-			}]
-		},
-		authClient: {
-			function: "oidcClient",
-			imports: [{
-				path: "better-auth/client/plugins",
-				imports: [createImport({ name: "oidcClient" })],
-				isNamedImport: false
-			}]
-		}
-	},
 	admin: {
 		displayName: "Admin",
 		auth: {
@@ -5284,12 +5562,9 @@ const databasesConfig = [
 			imports: [createImport({ name: "createPool" })],
 			isNamedImport: false
 		}],
-		preCode: `const dialect = createPool({ host: "localhost", user: "root", password: "password", database: "database", timezone: "Z" })`,
+		preCode: `const database = createPool({ host: "localhost", user: "root", password: "password", database: "database", timezone: "Z" })`,
 		code({ additionalOptions }) {
-			return kyselyCode({
-				provider: "mysql",
-				additionalOptions
-			});
+			return `database`;
 		},
 		dependencies: ["mysql2"]
 	},
@@ -5300,12 +5575,9 @@ const databasesConfig = [
 			imports: [createImport({ name: "Pool" })],
 			isNamedImport: false
 		}],
-		preCode: `const dialect = new Pool({ connectionString: "postgresql://postgres:password@localhost:5432/database" })`,
+		preCode: `const database = new Pool({ connectionString: "postgresql://postgres:password@localhost:5432/database" })`,
 		code({ additionalOptions }) {
-			return kyselyCode({
-				provider: "postgresql",
-				additionalOptions
-			});
+			return `database`;
 		},
 		dependencies: ["pg"],
 		devDependencies: ["@types/pg"]
@@ -6671,7 +6943,7 @@ const initActionOptionsSchema = z.object({
 //#region src/commands/login.ts
 async function loginAction() {
 	try {
-		await spawnCommand("npx @better-auth/cli@latest login");
+		await spawnCommand("npx auth@latest login");
 	} catch (error) {
 		log.error(error.message || "An unknown error occurred");
 		process.exit(1);
@@ -6681,7 +6953,7 @@ async function loginAction() {
 const login = new Command("login").description("Login to Better Auth Infrastructure").action(loginAction);
 async function logoutAction() {
 	try {
-		await spawnCommand("npx @better-auth/cli@latest logout");
+		await spawnCommand("npx auth@latest logout");
 	} catch (error) {
 		log.error(error.message || "An unknown error occurred");
 		process.exit(1);
@@ -7083,7 +7355,7 @@ async function main() {
 		packageInfo = await getPackageInfo();
 		cliVersion = packageInfo.version || "1.1.2";
 	} catch {}
-	program.addCommand(ai).addCommand(init).addCommand(migrate).addCommand(generate).addCommand(generateSecret).addCommand(info).addCommand(login).addCommand(logout).addCommand(mcp).addCommand(upgrade).version(cliVersion).description("Better Auth CLI").action(() => program.help());
+	program.addCommand(ai).addCommand(createAdmin).addCommand(init).addCommand(migrate).addCommand(generate).addCommand(generateSecret).addCommand(info).addCommand(login).addCommand(logout).addCommand(mcp).addCommand(upgrade).version(cliVersion).description("Better Auth CLI").action(() => program.help());
 	program.parse();
 }
 main().catch((error) => {