create-croissant 0.1.0 → 0.1.1

package/template/apps/web/node_modules/@better-auth/core/dist/env/color-depth.d.mts

@@ -0,0 +1,4 @@
+//#region src/env/color-depth.d.ts
+declare function getColorDepth(): number;
+//#endregion
+export { getColorDepth };

package/template/apps/web/node_modules/@better-auth/core/dist/env/color-depth.mjs

@@ -0,0 +1,86 @@
+import { env, getEnvVar } from "./env-impl.mjs";
+//#region src/env/color-depth.ts
+const COLORS_2 = 1;
+const COLORS_16 = 4;
+const COLORS_256 = 8;
+const COLORS_16m = 24;
+const TERM_ENVS = {
+	eterm: COLORS_16,
+	cons25: COLORS_16,
+	console: COLORS_16,
+	cygwin: COLORS_16,
+	dtterm: COLORS_16,
+	gnome: COLORS_16,
+	hurd: COLORS_16,
+	jfbterm: COLORS_16,
+	konsole: COLORS_16,
+	kterm: COLORS_16,
+	mlterm: COLORS_16,
+	mosh: COLORS_16m,
+	putty: COLORS_16,
+	st: COLORS_16,
+	"rxvt-unicode-24bit": COLORS_16m,
+	terminator: COLORS_16m,
+	"xterm-kitty": COLORS_16m
+};
+const CI_ENVS_MAP = new Map(Object.entries({
+	APPVEYOR: COLORS_256,
+	BUILDKITE: COLORS_256,
+	CIRCLECI: COLORS_16m,
+	DRONE: COLORS_256,
+	GITEA_ACTIONS: COLORS_16m,
+	GITHUB_ACTIONS: COLORS_16m,
+	GITLAB_CI: COLORS_256,
+	TRAVIS: COLORS_256
+}));
+const TERM_ENVS_REG_EXP = [
+	/ansi/,
+	/color/,
+	/linux/,
+	/direct/,
+	/^con[0-9]*x[0-9]/,
+	/^rxvt/,
+	/^screen/,
+	/^xterm/,
+	/^vt100/,
+	/^vt220/
+];
+function getColorDepth() {
+	if (getEnvVar("FORCE_COLOR") !== void 0) switch (getEnvVar("FORCE_COLOR")) {
+		case "":
+		case "1":
+		case "true": return COLORS_16;
+		case "2": return COLORS_256;
+		case "3": return COLORS_16m;
+		default: return COLORS_2;
+	}
+	if (getEnvVar("NODE_DISABLE_COLORS") !== void 0 && getEnvVar("NODE_DISABLE_COLORS") !== "" || getEnvVar("NO_COLOR") !== void 0 && getEnvVar("NO_COLOR") !== "" || getEnvVar("TERM") === "dumb") return COLORS_2;
+	if (getEnvVar("TMUX")) return COLORS_16m;
+	if ("TF_BUILD" in env && "AGENT_NAME" in env) return COLORS_16;
+	if ("CI" in env) {
+		for (const { 0: envName, 1: colors } of CI_ENVS_MAP) if (envName in env) return colors;
+		if (getEnvVar("CI_NAME") === "codeship") return COLORS_256;
+		return COLORS_2;
+	}
+	if ("TEAMCITY_VERSION" in env) return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.exec(getEnvVar("TEAMCITY_VERSION")) !== null ? COLORS_16 : COLORS_2;
+	switch (getEnvVar("TERM_PROGRAM")) {
+		case "iTerm.app":
+			if (!getEnvVar("TERM_PROGRAM_VERSION") || /^[0-2]\./.exec(getEnvVar("TERM_PROGRAM_VERSION")) !== null) return COLORS_256;
+			return COLORS_16m;
+		case "HyperTerm":
+		case "MacTerm": return COLORS_16m;
+		case "Apple_Terminal": return COLORS_256;
+	}
+	if (getEnvVar("COLORTERM") === "truecolor" || getEnvVar("COLORTERM") === "24bit") return COLORS_16m;
+	if (getEnvVar("TERM")) {
+		if (/truecolor/.exec(getEnvVar("TERM")) !== null) return COLORS_16m;
+		if (/^xterm-256/.exec(getEnvVar("TERM")) !== null) return COLORS_256;
+		const termEnv = getEnvVar("TERM").toLowerCase();
+		if (TERM_ENVS[termEnv]) return TERM_ENVS[termEnv];
+		if (TERM_ENVS_REG_EXP.some((term) => term.exec(termEnv) !== null)) return COLORS_16;
+	}
+	if (getEnvVar("COLORTERM")) return COLORS_16;
+	return COLORS_2;
+}
+//#endregion
+export { getColorDepth };

package/template/apps/web/node_modules/@better-auth/core/dist/env/env-impl.d.mts

@@ -0,0 +1,32 @@
+//#region src/env/env-impl.d.ts
+type EnvObject = Record<string, string | undefined>;
+declare const env: EnvObject;
+declare const nodeENV: string;
+/** Detect if `NODE_ENV` environment variable is `production` */
+declare const isProduction: boolean;
+/** Detect if `NODE_ENV` environment variable is `dev` or `development` */
+declare const isDevelopment: () => boolean;
+/** Detect if `NODE_ENV` environment variable is `test` */
+declare const isTest: () => boolean;
+/**
+ * Get environment variable with fallback
+ */
+declare function getEnvVar<Fallback extends string>(key: string, fallback?: Fallback): Fallback extends string ? string : string | undefined;
+/**
+ * Get boolean environment variable
+ */
+declare function getBooleanEnvVar(key: string, fallback?: boolean): boolean;
+/**
+ * Common environment variables used in Better Auth
+ */
+declare const ENV: Readonly<{
+  readonly BETTER_AUTH_SECRET: string;
+  readonly AUTH_SECRET: string;
+  readonly BETTER_AUTH_TELEMETRY: string;
+  readonly BETTER_AUTH_TELEMETRY_ID: string;
+  readonly NODE_ENV: string;
+  readonly PACKAGE_VERSION: string;
+  readonly BETTER_AUTH_TELEMETRY_ENDPOINT: string | undefined;
+}>;
+//#endregion
+export { ENV, EnvObject, env, getBooleanEnvVar, getEnvVar, isDevelopment, isProduction, isTest, nodeENV };

package/template/apps/web/node_modules/@better-auth/core/dist/env/env-impl.mjs

@@ -0,0 +1,81 @@
+//#region src/env/env-impl.ts
+const _envShim = Object.create(null);
+const _getEnv = (useShim) => globalThis.process?.env || globalThis.Deno?.env.toObject() || globalThis.__env__ || (useShim ? _envShim : globalThis);
+const env = new Proxy(_envShim, {
+	get(_, prop) {
+		return _getEnv()[prop] ?? _envShim[prop];
+	},
+	has(_, prop) {
+		return prop in _getEnv() || prop in _envShim;
+	},
+	set(_, prop, value) {
+		const env = _getEnv(true);
+		env[prop] = value;
+		return true;
+	},
+	deleteProperty(_, prop) {
+		if (!prop) return false;
+		const env = _getEnv(true);
+		delete env[prop];
+		return true;
+	},
+	ownKeys() {
+		const env = _getEnv(true);
+		return Object.keys(env);
+	}
+});
+function toBoolean(val) {
+	return val ? val !== "false" : false;
+}
+const nodeENV = typeof process !== "undefined" && process.env && process.env.NODE_ENV || "";
+/** Detect if `NODE_ENV` environment variable is `production` */
+const isProduction = nodeENV === "production";
+/** Detect if `NODE_ENV` environment variable is `dev` or `development` */
+const isDevelopment = () => nodeENV === "dev" || nodeENV === "development";
+/** Detect if `NODE_ENV` environment variable is `test` */
+const isTest = () => nodeENV === "test" || toBoolean(env.TEST);
+/**
+* Get environment variable with fallback
+*/
+function getEnvVar(key, fallback) {
+	if (typeof process !== "undefined" && process.env) return process.env[key] ?? fallback;
+	if (typeof Deno !== "undefined") return Deno.env.get(key) ?? fallback;
+	if (typeof Bun !== "undefined") return Bun.env[key] ?? fallback;
+	return fallback;
+}
+/**
+* Get boolean environment variable
+*/
+function getBooleanEnvVar(key, fallback = true) {
+	const value = getEnvVar(key);
+	if (!value) return fallback;
+	return value !== "0" && value.toLowerCase() !== "false" && value !== "";
+}
+/**
+* Common environment variables used in Better Auth
+*/
+const ENV = Object.freeze({
+	get BETTER_AUTH_SECRET() {
+		return getEnvVar("BETTER_AUTH_SECRET");
+	},
+	get AUTH_SECRET() {
+		return getEnvVar("AUTH_SECRET");
+	},
+	get BETTER_AUTH_TELEMETRY() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY");
+	},
+	get BETTER_AUTH_TELEMETRY_ID() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY_ID");
+	},
+	get NODE_ENV() {
+		return getEnvVar("NODE_ENV", "development");
+	},
+	get PACKAGE_VERSION() {
+		return getEnvVar("PACKAGE_VERSION", "0.0.0");
+	},
+	get BETTER_AUTH_TELEMETRY_ENDPOINT() {
+		return getEnvVar("BETTER_AUTH_TELEMETRY_ENDPOINT", "");
+	}
+});
+//#endregion
+export { ENV, env, getBooleanEnvVar, getEnvVar, isDevelopment, isProduction, isTest, nodeENV };

package/template/apps/web/node_modules/@better-auth/core/dist/env/index.d.mts

@@ -0,0 +1,4 @@
+import { getColorDepth } from "./color-depth.mjs";
+import { ENV, EnvObject, env, getBooleanEnvVar, getEnvVar, isDevelopment, isProduction, isTest, nodeENV } from "./env-impl.mjs";
+import { InternalLogger, LogHandlerParams, LogLevel, Logger, TTY_COLORS, createLogger, levels, logger, shouldPublishLog } from "./logger.mjs";
+export { ENV, type EnvObject, type InternalLogger, type LogHandlerParams, type LogLevel, type Logger, TTY_COLORS, createLogger, env, getBooleanEnvVar, getColorDepth, getEnvVar, isDevelopment, isProduction, isTest, levels, logger, nodeENV, shouldPublishLog };

package/template/apps/web/node_modules/@better-auth/core/dist/env/index.mjs

@@ -0,0 +1,4 @@
+import { ENV, env, getBooleanEnvVar, getEnvVar, isDevelopment, isProduction, isTest, nodeENV } from "./env-impl.mjs";
+import { getColorDepth } from "./color-depth.mjs";
+import { TTY_COLORS, createLogger, levels, logger, shouldPublishLog } from "./logger.mjs";
+export { ENV, TTY_COLORS, createLogger, env, getBooleanEnvVar, getColorDepth, getEnvVar, isDevelopment, isProduction, isTest, levels, logger, nodeENV, shouldPublishLog };

package/template/apps/web/node_modules/@better-auth/core/dist/env/logger.d.mts

@@ -0,0 +1,48 @@
+//#region src/env/logger.d.ts
+declare const TTY_COLORS: {
+  readonly reset: "\u001B[0m";
+  readonly bright: "\u001B[1m";
+  readonly dim: "\u001B[2m";
+  readonly undim: "\u001B[22m";
+  readonly underscore: "\u001B[4m";
+  readonly blink: "\u001B[5m";
+  readonly reverse: "\u001B[7m";
+  readonly hidden: "\u001B[8m";
+  readonly fg: {
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+  };
+  readonly bg: {
+    readonly black: "\u001B[40m";
+    readonly red: "\u001B[41m";
+    readonly green: "\u001B[42m";
+    readonly yellow: "\u001B[43m";
+    readonly blue: "\u001B[44m";
+    readonly magenta: "\u001B[45m";
+    readonly cyan: "\u001B[46m";
+    readonly white: "\u001B[47m";
+  };
+};
+type LogLevel = "debug" | "info" | "success" | "warn" | "error";
+declare const levels: readonly ["debug", "info", "success", "warn", "error"];
+declare function shouldPublishLog(currentLogLevel: LogLevel, logLevel: LogLevel): boolean;
+interface Logger {
+  disabled?: boolean | undefined;
+  disableColors?: boolean | undefined;
+  level?: Exclude<LogLevel, "success"> | undefined;
+  log?: ((level: Exclude<LogLevel, "success">, message: string, ...args: any[]) => void) | undefined;
+}
+type LogHandlerParams = Parameters<NonNullable<Logger["log"]>> extends [LogLevel, ...infer Rest] ? Rest : never;
+type InternalLogger = { [K in LogLevel]: (...params: LogHandlerParams) => void } & {
+  get level(): LogLevel;
+};
+declare const createLogger: (options?: Logger | undefined) => InternalLogger;
+declare const logger: InternalLogger;
+//#endregion
+export { InternalLogger, LogHandlerParams, LogLevel, Logger, TTY_COLORS, createLogger, levels, logger, shouldPublishLog };

package/template/apps/web/node_modules/@better-auth/core/dist/env/logger.mjs

@@ -0,0 +1,79 @@
+import { getColorDepth } from "./color-depth.mjs";
+//#region src/env/logger.ts
+const TTY_COLORS = {
+	reset: "\x1B[0m",
+	bright: "\x1B[1m",
+	dim: "\x1B[2m",
+	undim: "\x1B[22m",
+	underscore: "\x1B[4m",
+	blink: "\x1B[5m",
+	reverse: "\x1B[7m",
+	hidden: "\x1B[8m",
+	fg: {
+		black: "\x1B[30m",
+		red: "\x1B[31m",
+		green: "\x1B[32m",
+		yellow: "\x1B[33m",
+		blue: "\x1B[34m",
+		magenta: "\x1B[35m",
+		cyan: "\x1B[36m",
+		white: "\x1B[37m"
+	},
+	bg: {
+		black: "\x1B[40m",
+		red: "\x1B[41m",
+		green: "\x1B[42m",
+		yellow: "\x1B[43m",
+		blue: "\x1B[44m",
+		magenta: "\x1B[45m",
+		cyan: "\x1B[46m",
+		white: "\x1B[47m"
+	}
+};
+const levels = [
+	"debug",
+	"info",
+	"success",
+	"warn",
+	"error"
+];
+function shouldPublishLog(currentLogLevel, logLevel) {
+	return levels.indexOf(logLevel) >= levels.indexOf(currentLogLevel);
+}
+const levelColors = {
+	info: TTY_COLORS.fg.blue,
+	success: TTY_COLORS.fg.green,
+	warn: TTY_COLORS.fg.yellow,
+	error: TTY_COLORS.fg.red,
+	debug: TTY_COLORS.fg.magenta
+};
+const formatMessage = (level, message, colorsEnabled) => {
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	if (colorsEnabled) return `${TTY_COLORS.dim}${timestamp}${TTY_COLORS.reset} ${levelColors[level]}${level.toUpperCase()}${TTY_COLORS.reset} ${TTY_COLORS.bright}[Better Auth]:${TTY_COLORS.reset} ${message}`;
+	return `${timestamp} ${level.toUpperCase()} [Better Auth]: ${message}`;
+};
+const createLogger = (options) => {
+	const enabled = options?.disabled !== true;
+	const logLevel = options?.level ?? "warn";
+	const colorsEnabled = options?.disableColors !== void 0 ? !options.disableColors : getColorDepth() !== 1;
+	const LogFunc = (level, message, args = []) => {
+		if (!enabled || !shouldPublishLog(logLevel, level)) return;
+		const formattedMessage = formatMessage(level, message, colorsEnabled);
+		if (!options || typeof options.log !== "function") {
+			if (level === "error") console.error(formattedMessage, ...args);
+			else if (level === "warn") console.warn(formattedMessage, ...args);
+			else console.log(formattedMessage, ...args);
+			return;
+		}
+		options.log(level === "success" ? "info" : level, message, ...args);
+	};
+	return {
+		...Object.fromEntries(levels.map((level) => [level, (...[message, ...args]) => LogFunc(level, message, args)])),
+		get level() {
+			return logLevel;
+		}
+	};
+};
+const logger = createLogger();
+//#endregion
+export { TTY_COLORS, createLogger, levels, logger, shouldPublishLog };

package/template/apps/web/node_modules/@better-auth/core/dist/error/codes.d.mts

@@ -0,0 +1,68 @@
+import { RawError } from "../utils/error-codes.mjs";
+
+//#region src/error/codes.d.ts
+declare module "@better-auth/core" {
+  interface BetterAuthPluginRegistry<AuthOptions, Options> {
+    /**
+     * This plugin does not exist, do not use it in runtime.
+     */
+    "$internal:base": {
+      creator: () => {
+        $ERROR_CODES: typeof BASE_ERROR_CODES;
+      };
+    };
+  }
+}
+declare const BASE_ERROR_CODES: {
+  USER_NOT_FOUND: RawError<"USER_NOT_FOUND">;
+  FAILED_TO_CREATE_USER: RawError<"FAILED_TO_CREATE_USER">;
+  FAILED_TO_CREATE_SESSION: RawError<"FAILED_TO_CREATE_SESSION">;
+  FAILED_TO_UPDATE_USER: RawError<"FAILED_TO_UPDATE_USER">;
+  FAILED_TO_GET_SESSION: RawError<"FAILED_TO_GET_SESSION">;
+  INVALID_PASSWORD: RawError<"INVALID_PASSWORD">;
+  INVALID_EMAIL: RawError<"INVALID_EMAIL">;
+  INVALID_EMAIL_OR_PASSWORD: RawError<"INVALID_EMAIL_OR_PASSWORD">;
+  INVALID_USER: RawError<"INVALID_USER">;
+  SOCIAL_ACCOUNT_ALREADY_LINKED: RawError<"SOCIAL_ACCOUNT_ALREADY_LINKED">;
+  PROVIDER_NOT_FOUND: RawError<"PROVIDER_NOT_FOUND">;
+  INVALID_TOKEN: RawError<"INVALID_TOKEN">;
+  TOKEN_EXPIRED: RawError<"TOKEN_EXPIRED">;
+  ID_TOKEN_NOT_SUPPORTED: RawError<"ID_TOKEN_NOT_SUPPORTED">;
+  FAILED_TO_GET_USER_INFO: RawError<"FAILED_TO_GET_USER_INFO">;
+  USER_EMAIL_NOT_FOUND: RawError<"USER_EMAIL_NOT_FOUND">;
+  EMAIL_NOT_VERIFIED: RawError<"EMAIL_NOT_VERIFIED">;
+  PASSWORD_TOO_SHORT: RawError<"PASSWORD_TOO_SHORT">;
+  PASSWORD_TOO_LONG: RawError<"PASSWORD_TOO_LONG">;
+  USER_ALREADY_EXISTS: RawError<"USER_ALREADY_EXISTS">;
+  USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: RawError<"USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL">;
+  EMAIL_CAN_NOT_BE_UPDATED: RawError<"EMAIL_CAN_NOT_BE_UPDATED">;
+  CREDENTIAL_ACCOUNT_NOT_FOUND: RawError<"CREDENTIAL_ACCOUNT_NOT_FOUND">;
+  ACCOUNT_NOT_FOUND: RawError<"ACCOUNT_NOT_FOUND">;
+  SESSION_EXPIRED: RawError<"SESSION_EXPIRED">;
+  FAILED_TO_UNLINK_LAST_ACCOUNT: RawError<"FAILED_TO_UNLINK_LAST_ACCOUNT">;
+  USER_ALREADY_HAS_PASSWORD: RawError<"USER_ALREADY_HAS_PASSWORD">;
+  CROSS_SITE_NAVIGATION_LOGIN_BLOCKED: RawError<"CROSS_SITE_NAVIGATION_LOGIN_BLOCKED">;
+  VERIFICATION_EMAIL_NOT_ENABLED: RawError<"VERIFICATION_EMAIL_NOT_ENABLED">;
+  EMAIL_ALREADY_VERIFIED: RawError<"EMAIL_ALREADY_VERIFIED">;
+  EMAIL_MISMATCH: RawError<"EMAIL_MISMATCH">;
+  SESSION_NOT_FRESH: RawError<"SESSION_NOT_FRESH">;
+  LINKED_ACCOUNT_ALREADY_EXISTS: RawError<"LINKED_ACCOUNT_ALREADY_EXISTS">;
+  INVALID_ORIGIN: RawError<"INVALID_ORIGIN">;
+  INVALID_CALLBACK_URL: RawError<"INVALID_CALLBACK_URL">;
+  INVALID_REDIRECT_URL: RawError<"INVALID_REDIRECT_URL">;
+  INVALID_ERROR_CALLBACK_URL: RawError<"INVALID_ERROR_CALLBACK_URL">;
+  INVALID_NEW_USER_CALLBACK_URL: RawError<"INVALID_NEW_USER_CALLBACK_URL">;
+  MISSING_OR_NULL_ORIGIN: RawError<"MISSING_OR_NULL_ORIGIN">;
+  CALLBACK_URL_REQUIRED: RawError<"CALLBACK_URL_REQUIRED">;
+  FAILED_TO_CREATE_VERIFICATION: RawError<"FAILED_TO_CREATE_VERIFICATION">;
+  FIELD_NOT_ALLOWED: RawError<"FIELD_NOT_ALLOWED">;
+  ASYNC_VALIDATION_NOT_SUPPORTED: RawError<"ASYNC_VALIDATION_NOT_SUPPORTED">;
+  VALIDATION_ERROR: RawError<"VALIDATION_ERROR">;
+  MISSING_FIELD: RawError<"MISSING_FIELD">;
+  METHOD_NOT_ALLOWED_DEFER_SESSION_REQUIRED: RawError<"METHOD_NOT_ALLOWED_DEFER_SESSION_REQUIRED">;
+  BODY_MUST_BE_AN_OBJECT: RawError<"BODY_MUST_BE_AN_OBJECT">;
+  PASSWORD_ALREADY_SET: RawError<"PASSWORD_ALREADY_SET">;
+};
+type APIErrorCode = keyof typeof BASE_ERROR_CODES;
+//#endregion
+export { APIErrorCode, BASE_ERROR_CODES };

package/template/apps/web/node_modules/@better-auth/core/dist/error/codes.mjs

@@ -0,0 +1,54 @@
+import { defineErrorCodes } from "../utils/error-codes.mjs";
+//#region src/error/codes.ts
+const BASE_ERROR_CODES = defineErrorCodes({
+	USER_NOT_FOUND: "User not found",
+	FAILED_TO_CREATE_USER: "Failed to create user",
+	FAILED_TO_CREATE_SESSION: "Failed to create session",
+	FAILED_TO_UPDATE_USER: "Failed to update user",
+	FAILED_TO_GET_SESSION: "Failed to get session",
+	INVALID_PASSWORD: "Invalid password",
+	INVALID_EMAIL: "Invalid email",
+	INVALID_EMAIL_OR_PASSWORD: "Invalid email or password",
+	INVALID_USER: "Invalid user",
+	SOCIAL_ACCOUNT_ALREADY_LINKED: "Social account already linked",
+	PROVIDER_NOT_FOUND: "Provider not found",
+	INVALID_TOKEN: "Invalid token",
+	TOKEN_EXPIRED: "Token expired",
+	ID_TOKEN_NOT_SUPPORTED: "id_token not supported",
+	FAILED_TO_GET_USER_INFO: "Failed to get user info",
+	USER_EMAIL_NOT_FOUND: "User email not found",
+	EMAIL_NOT_VERIFIED: "Email not verified",
+	PASSWORD_TOO_SHORT: "Password too short",
+	PASSWORD_TOO_LONG: "Password too long",
+	USER_ALREADY_EXISTS: "User already exists.",
+	USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: "User already exists. Use another email.",
+	EMAIL_CAN_NOT_BE_UPDATED: "Email can not be updated",
+	CREDENTIAL_ACCOUNT_NOT_FOUND: "Credential account not found",
+	SESSION_EXPIRED: "Session expired. Re-authenticate to perform this action.",
+	FAILED_TO_UNLINK_LAST_ACCOUNT: "You can't unlink your last account",
+	ACCOUNT_NOT_FOUND: "Account not found",
+	USER_ALREADY_HAS_PASSWORD: "User already has a password. Provide that to delete the account.",
+	CROSS_SITE_NAVIGATION_LOGIN_BLOCKED: "Cross-site navigation login blocked. This request appears to be a CSRF attack.",
+	VERIFICATION_EMAIL_NOT_ENABLED: "Verification email isn't enabled",
+	EMAIL_ALREADY_VERIFIED: "Email is already verified",
+	EMAIL_MISMATCH: "Email mismatch",
+	SESSION_NOT_FRESH: "Session is not fresh",
+	LINKED_ACCOUNT_ALREADY_EXISTS: "Linked account already exists",
+	INVALID_ORIGIN: "Invalid origin",
+	INVALID_CALLBACK_URL: "Invalid callbackURL",
+	INVALID_REDIRECT_URL: "Invalid redirectURL",
+	INVALID_ERROR_CALLBACK_URL: "Invalid errorCallbackURL",
+	INVALID_NEW_USER_CALLBACK_URL: "Invalid newUserCallbackURL",
+	MISSING_OR_NULL_ORIGIN: "Missing or null Origin",
+	CALLBACK_URL_REQUIRED: "callbackURL is required",
+	FAILED_TO_CREATE_VERIFICATION: "Unable to create verification",
+	FIELD_NOT_ALLOWED: "Field not allowed to be set",
+	ASYNC_VALIDATION_NOT_SUPPORTED: "Async validation is not supported",
+	VALIDATION_ERROR: "Validation Error",
+	MISSING_FIELD: "Field is required",
+	METHOD_NOT_ALLOWED_DEFER_SESSION_REQUIRED: "POST method requires deferSessionRefresh to be enabled in session config",
+	BODY_MUST_BE_AN_OBJECT: "Body must be an object",
+	PASSWORD_ALREADY_SET: "User already has a password set"
+});
+//#endregion
+export { BASE_ERROR_CODES };

package/template/apps/web/node_modules/@better-auth/core/dist/error/index.d.mts

@@ -0,0 +1,19 @@
+import { APIErrorCode, BASE_ERROR_CODES } from "./codes.mjs";
+import { APIError as APIError$1 } from "better-call/error";
+
+//#region src/error/index.d.ts
+declare class BetterAuthError extends Error {
+  constructor(message: string, options?: {
+    cause?: unknown | undefined;
+  });
+}
+declare class APIError extends APIError$1 {
+  constructor(...args: ConstructorParameters<typeof APIError$1>);
+  static fromStatus(status: ConstructorParameters<typeof APIError$1>[0], body?: ConstructorParameters<typeof APIError$1>[1]): APIError;
+  static from(status: ConstructorParameters<typeof APIError$1>[0], error: {
+    code: string;
+    message: string;
+  }): APIError;
+}
+//#endregion
+export { APIError, type APIErrorCode, BASE_ERROR_CODES, BetterAuthError };

package/template/apps/web/node_modules/@better-auth/core/dist/error/index.mjs

@@ -0,0 +1,27 @@
+import { BASE_ERROR_CODES } from "./codes.mjs";
+import { APIError as APIError$1 } from "better-call/error";
+//#region src/error/index.ts
+var BetterAuthError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "BetterAuthError";
+		this.message = message;
+		this.stack = "";
+	}
+};
+var APIError = class APIError extends APIError$1 {
+	constructor(...args) {
+		super(...args);
+	}
+	static fromStatus(status, body) {
+		return new APIError(status, body);
+	}
+	static from(status, error) {
+		return new APIError(status, {
+			message: error.message,
+			code: error.code
+		});
+	}
+};
+//#endregion
+export { APIError, BASE_ERROR_CODES, BetterAuthError };

package/template/apps/web/node_modules/@better-auth/core/dist/index.d.mts

@@ -0,0 +1,9 @@
+import { Awaitable, AwaitableFunction, LiteralString, LiteralUnion, Prettify, Primitive, UnionToIntersection } from "./types/helper.mjs";
+import { BetterAuthPlugin, BetterAuthPluginErrorCodePart, HookEndpointContext } from "./types/plugin.mjs";
+import { BaseURLConfig, BetterAuthAdvancedOptions, BetterAuthDBOptions, BetterAuthOptions, BetterAuthRateLimitOptions, BetterAuthRateLimitRule, BetterAuthRateLimitStorage, DynamicBaseURLConfig, GenerateIdFn, StoreIdentifierOption } from "./types/init-options.mjs";
+import { BetterAuthCookie, BetterAuthCookies } from "./types/cookie.mjs";
+import { SecretConfig } from "./types/secret.mjs";
+import { AuthContext, BetterAuthPluginRegistry, BetterAuthPluginRegistryIdentifier, GenericEndpointContext, InfoContext, InternalAdapter, PluginContext } from "./types/context.mjs";
+import { BetterAuthClientOptions, BetterAuthClientPlugin, ClientAtomListener, ClientFetchOption, ClientStore } from "./types/plugin-client.mjs";
+import { StandardSchemaV1 } from "./types/index.mjs";
+export { AuthContext, Awaitable, AwaitableFunction, BaseURLConfig, BetterAuthAdvancedOptions, BetterAuthClientOptions, BetterAuthClientPlugin, BetterAuthCookie, BetterAuthCookies, BetterAuthDBOptions, BetterAuthOptions, BetterAuthPlugin, BetterAuthPluginErrorCodePart, BetterAuthPluginRegistry, BetterAuthPluginRegistryIdentifier, BetterAuthRateLimitOptions, BetterAuthRateLimitRule, BetterAuthRateLimitStorage, ClientAtomListener, ClientFetchOption, ClientStore, DynamicBaseURLConfig, GenerateIdFn, GenericEndpointContext, HookEndpointContext, InfoContext, InternalAdapter, LiteralString, LiteralUnion, PluginContext, Prettify, Primitive, SecretConfig, StandardSchemaV1, StoreIdentifierOption, UnionToIntersection };

package/template/apps/web/node_modules/@better-auth/core/dist/index.mjs

@@ -0,0 +1 @@
+export {};

package/template/apps/web/node_modules/@better-auth/core/dist/instrumentation/api.mjs

@@ -0,0 +1,42 @@
+//#region src/instrumentation/api.ts
+function createNoopSpan() {
+	return {
+		end() {},
+		setAttribute(_key, _value) {},
+		setStatus(_status) {},
+		recordException(_exception) {}
+	};
+}
+function createNoopTracer(noopSpanInstance) {
+	function startActiveSpan(_name, _options, fn) {
+		return fn(noopSpanInstance);
+	}
+	return { startActiveSpan };
+}
+function createNoopTraceAPI() {
+	const noopTracer = createNoopTracer(createNoopSpan());
+	return { getTracer(_name, _version) {
+		return noopTracer;
+	} };
+}
+function createNoopOpenTelemetryAPI() {
+	return {
+		SpanStatusCode: {
+			UNSET: 0,
+			OK: 1,
+			ERROR: 2
+		},
+		trace: createNoopTraceAPI()
+	};
+}
+const noopOpenTelemetryAPI = createNoopOpenTelemetryAPI();
+let openTelemetryAPIPromise;
+let openTelemetryAPI;
+function getOpenTelemetryAPI() {
+	if (!openTelemetryAPIPromise) openTelemetryAPIPromise = import("@opentelemetry/api").then((mod) => {
+		openTelemetryAPI = mod;
+	}).catch(() => void 0);
+	return openTelemetryAPI ?? noopOpenTelemetryAPI;
+}
+//#endregion
+export { getOpenTelemetryAPI };

package/template/apps/web/node_modules/@better-auth/core/dist/instrumentation/attributes.d.mts

@@ -0,0 +1,11 @@
+import { ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE } from "@opentelemetry/semantic-conventions";
+
+//#region src/instrumentation/attributes.d.ts
+/** Operation identifier (e.g. getSession, signUpWithEmailAndPassword). Uses endpoint operationId when set, otherwise the endpoint key. */
+declare const ATTR_OPERATION_ID: "better_auth.operation_id";
+/** Hook type (e.g. before, after, create.before). */
+declare const ATTR_HOOK_TYPE: "better_auth.hook.type";
+/** Execution context (e.g. user, plugin:id). */
+declare const ATTR_CONTEXT: "better_auth.context";
+//#endregion
+export { ATTR_CONTEXT, ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME, ATTR_HOOK_TYPE, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_OPERATION_ID };

package/template/apps/web/node_modules/@better-auth/core/dist/instrumentation/attributes.mjs

@@ -0,0 +1,10 @@
+import { ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE } from "@opentelemetry/semantic-conventions";
+//#region src/instrumentation/attributes.ts
+/** Operation identifier (e.g. getSession, signUpWithEmailAndPassword). Uses endpoint operationId when set, otherwise the endpoint key. */
+const ATTR_OPERATION_ID = "better_auth.operation_id";
+/** Hook type (e.g. before, after, create.before). */
+const ATTR_HOOK_TYPE = "better_auth.hook.type";
+/** Execution context (e.g. user, plugin:id). */
+const ATTR_CONTEXT = "better_auth.context";
+//#endregion
+export { ATTR_CONTEXT, ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME, ATTR_HOOK_TYPE, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_OPERATION_ID };

package/template/apps/web/node_modules/@better-auth/core/dist/instrumentation/index.d.mts

@@ -0,0 +1,3 @@
+import { ATTR_CONTEXT, ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME, ATTR_HOOK_TYPE, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_OPERATION_ID } from "./attributes.mjs";
+import { withSpan } from "./tracer.mjs";
+export { ATTR_CONTEXT, ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME, ATTR_HOOK_TYPE, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_OPERATION_ID, withSpan };

package/template/apps/web/node_modules/@better-auth/core/dist/instrumentation/index.mjs

@@ -0,0 +1,3 @@
+import { ATTR_CONTEXT, ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME, ATTR_HOOK_TYPE, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_OPERATION_ID } from "./attributes.mjs";
+import { withSpan } from "./tracer.mjs";
+export { ATTR_CONTEXT, ATTR_DB_COLLECTION_NAME, ATTR_DB_OPERATION_NAME, ATTR_HOOK_TYPE, ATTR_HTTP_RESPONSE_STATUS_CODE, ATTR_HTTP_ROUTE, ATTR_OPERATION_ID, withSpan };

package/template/apps/web/node_modules/@better-auth/core/dist/instrumentation/tracer.d.mts

@@ -0,0 +1,13 @@
+//#region src/instrumentation/tracer.d.ts
+/**
+ * Creates a child span whose lifetime is bound to the execution of the given function
+ *
+ * @param name - The name of the span.
+ * @param attributes - The attributes of the span.
+ * @param fn - The function to execute within the span.
+ * @returns The result of the function.
+ */
+declare function withSpan<T>(name: string, attributes: Record<string, string | number | boolean>, fn: () => T): T;
+declare function withSpan<T>(name: string, attributes: Record<string, string | number | boolean>, fn: () => Promise<T>): Promise<T>;
+//#endregion
+export { withSpan };