@better-auth/electron 1.5.0-beta.12

package/dist/index.d.mts

@@ -0,0 +1,239 @@
+import * as better_auth0 from "better-auth";
+import * as z from "zod";
+import { HookEndpointContext } from "@better-auth/core";
+import * as better_call0 from "better-call";
+
+//#region src/types/options.d.ts
+interface ElectronOptions {
+  /**
+   * The duration (in seconds) for which the authorization code remains valid.
+   *
+   * @default 300 (5 minutes)
+   */
+  codeExpiresIn?: number | undefined;
+  /**
+   * The duration (in seconds) for which the redirect cookie remains valid.
+   *
+   * @default 120 (2 minutes)
+   */
+  redirectCookieExpiresIn?: number | undefined;
+  /**
+   * The prefix to use for cookies set by the plugin.
+   *
+   * @default "better-auth"
+   */
+  cookiePrefix?: string | undefined;
+  /**
+   * Client ID to use for identifying the Electron client during authorization.
+   *
+   * @default "electron"
+   */
+  clientID?: string | undefined;
+  /**
+   * Override the origin for Electron API routes.
+   * Enable this if you're facing cors origin issues with Electron API routes.
+   *
+   * @default false
+   */
+  disableOriginOverride?: boolean | undefined;
+}
+//#endregion
+//#region src/index.d.ts
+declare module "@better-auth/core" {
+  interface BetterAuthPluginRegistry<AuthOptions, Options> {
+    electron: {
+      creator: typeof electron;
+    };
+  }
+}
+declare const electron: (options?: ElectronOptions | undefined) => {
+  id: "electron";
+  onRequest(request: Request, _ctx: better_auth0.AuthContext): Promise<{
+    request: Request;
+  } | undefined>;
+  hooks: {
+    after: ({
+      matcher: (ctx: HookEndpointContext) => boolean;
+      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+    } | {
+      matcher: (ctx: HookEndpointContext) => boolean;
+      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<better_call0.MiddlewareContext<better_call0.MiddlewareOptions, {
+        returned?: unknown | undefined;
+        responseHeaders?: Headers | undefined;
+      } & better_auth0.PluginContext<better_auth0.BetterAuthOptions> & better_auth0.InfoContext & {
+        options: better_auth0.BetterAuthOptions;
+        trustedOrigins: string[];
+        isTrustedOrigin: (url: string, settings?: {
+          allowRelativePaths: boolean;
+        }) => boolean;
+        oauthConfig: {
+          skipStateCookieCheck?: boolean | undefined;
+          storeStateStrategy: "database" | "cookie";
+        };
+        newSession: {
+          session: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+          } & Record<string, any>;
+          user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          } & Record<string, any>;
+        } | null;
+        session: {
+          session: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+          } & Record<string, any>;
+          user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          } & Record<string, any>;
+        } | null;
+        setNewSession: (session: {
+          session: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            userId: string;
+            expiresAt: Date;
+            token: string;
+            ipAddress?: string | null | undefined;
+            userAgent?: string | null | undefined;
+          } & Record<string, any>;
+          user: {
+            id: string;
+            createdAt: Date;
+            updatedAt: Date;
+            email: string;
+            emailVerified: boolean;
+            name: string;
+            image?: string | null | undefined;
+          } & Record<string, any>;
+        } | null) => void;
+        socialProviders: better_auth0.OAuthProvider[];
+        authCookies: better_auth0.BetterAuthCookies;
+        logger: ReturnType<typeof better_auth0.createLogger>;
+        rateLimit: {
+          enabled: boolean;
+          window: number;
+          max: number;
+          storage: "memory" | "database" | "secondary-storage";
+        } & Omit<better_auth0.BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
+        adapter: better_auth0.DBAdapter<better_auth0.BetterAuthOptions>;
+        internalAdapter: better_auth0.InternalAdapter<better_auth0.BetterAuthOptions>;
+        createAuthCookie: (cookieName: string, overrideAttributes?: Partial<better_call0.CookieOptions> | undefined) => better_auth0.BetterAuthCookie;
+        secret: string;
+        sessionConfig: {
+          updateAge: number;
+          expiresIn: number;
+          freshAge: number;
+          cookieRefreshCache: false | {
+            enabled: true;
+            updateAge: number;
+          };
+        };
+        generateId: (options: {
+          model: better_auth0.ModelNames;
+          size?: number | undefined;
+        }) => string | false;
+        secondaryStorage: better_auth0.SecondaryStorage | undefined;
+        password: {
+          hash: (password: string) => Promise<string>;
+          verify: (data: {
+            password: string;
+            hash: string;
+          }) => Promise<boolean>;
+          config: {
+            minPasswordLength: number;
+            maxPasswordLength: number;
+          };
+          checkPassword: (userId: string, ctx: better_auth0.GenericEndpointContext<better_auth0.BetterAuthOptions>) => Promise<boolean>;
+        };
+        tables: better_auth0.BetterAuthDBSchema;
+        runMigrations: () => Promise<void>;
+        publishTelemetry: (event: {
+          type: string;
+          anonymousId?: string | undefined;
+          payload: Record<string, any>;
+        }) => Promise<void>;
+        skipOriginCheck: boolean | string[];
+        skipCSRFCheck: boolean;
+        runInBackground: (promise: Promise<unknown>) => void;
+        runInBackgroundOrAwait: (promise: Promise<unknown> | void) => better_auth0.Awaitable<unknown>;
+      }> | undefined>;
+    })[];
+  };
+  endpoints: {
+    electronToken: better_call0.StrictEndpoint<"/electron/token", {
+      method: "POST";
+      body: z.ZodObject<{
+        token: z.ZodString;
+        state: z.ZodString;
+        code_verifier: z.ZodString;
+      }, z.core.$strip>;
+      metadata: {
+        scope: "http";
+      };
+    }, {
+      token: string;
+      user: better_auth0.User & Record<string, any>;
+    }>;
+    electronInitOAuthProxy: better_call0.StrictEndpoint<"/electron/init-oauth-proxy", {
+      method: "GET";
+      query: z.ZodObject<{
+        provider: z.ZodString;
+        state: z.ZodString;
+        code_challenge: z.ZodString;
+        code_challenge_method: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>;
+      metadata: {
+        scope: "http";
+      };
+    }, {
+      url: string | undefined;
+      redirect: boolean;
+      user?: better_auth0.User & Record<string, any>;
+      token?: string;
+    } | undefined>;
+  };
+  options: {
+    codeExpiresIn: number;
+    redirectCookieExpiresIn: number;
+    cookiePrefix: string;
+    clientID: string;
+    disableOriginOverride?: boolean | undefined;
+  };
+  $ERROR_CODES: {
+    INVALID_TOKEN: better_auth0.RawError<"INVALID_TOKEN">;
+    STATE_MISMATCH: better_auth0.RawError<"STATE_MISMATCH">;
+    MISSING_CODE_CHALLENGE: better_auth0.RawError<"MISSING_CODE_CHALLENGE">;
+    INVALID_CODE_VERIFIER: better_auth0.RawError<"INVALID_CODE_VERIFIER">;
+    MISSING_STATE: better_auth0.RawError<"MISSING_STATE">;
+    MISSING_PKCE: better_auth0.RawError<"MISSING_PKCE">;
+  };
+};
+//#endregion
+export { ElectronOptions, electron };

package/dist/index.mjs

@@ -0,0 +1,201 @@
+import { createAuthMiddleware } from "@better-auth/core/api";
+import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
+import { defineErrorCodes, safeJSONParse } from "better-auth";
+import { generateRandomString } from "better-auth/crypto";
+import * as z from "zod";
+import { Buffer } from "node:buffer";
+import { timingSafeEqual } from "node:crypto";
+import { SocialProviderListEnum } from "@better-auth/core/social-providers";
+import { safeJSONParse as safeJSONParse$1 } from "@better-auth/core/utils/json";
+import { base64Url } from "@better-auth/utils/base64";
+import { createHash } from "@better-auth/utils/hash";
+import { betterFetch } from "@better-fetch/fetch";
+import { createAuthEndpoint } from "better-auth/api";
+import { setSessionCookie } from "better-auth/cookies";
+import { parseUserOutput } from "better-auth/db";
+
+//#region src/error-codes.ts
+const ELECTRON_ERROR_CODES = defineErrorCodes({
+	INVALID_TOKEN: "Invalid or expired token.",
+	STATE_MISMATCH: "state mismatch",
+	MISSING_CODE_CHALLENGE: "missing code challenge",
+	INVALID_CODE_VERIFIER: "Invalid code verifier",
+	MISSING_STATE: "state is required",
+	MISSING_PKCE: "pkce is required"
+});
+
+//#endregion
+//#region src/routes.ts
+const electronTokenBodySchema = z.object({
+	token: z.string().nonempty(),
+	state: z.string().nonempty(),
+	code_verifier: z.string().nonempty()
+});
+const electronToken = (opts) => createAuthEndpoint("/electron/token", {
+	method: "POST",
+	body: electronTokenBodySchema,
+	metadata: { scope: "http" }
+}, async (ctx) => {
+	const token = await ctx.context.internalAdapter.findVerificationValue(`electron:${ctx.body.token}`);
+	if (!token || token.expiresAt < /* @__PURE__ */ new Date()) throw APIError.from("NOT_FOUND", ELECTRON_ERROR_CODES.INVALID_TOKEN);
+	const tokenRecord = safeJSONParse$1(token.value);
+	if (!tokenRecord) throw APIError.from("INTERNAL_SERVER_ERROR", ELECTRON_ERROR_CODES.INVALID_TOKEN);
+	if (tokenRecord.state !== ctx.body.state) throw APIError.from("BAD_REQUEST", ELECTRON_ERROR_CODES.STATE_MISMATCH);
+	if (!tokenRecord.codeChallenge) throw APIError.from("BAD_REQUEST", ELECTRON_ERROR_CODES.MISSING_CODE_CHALLENGE);
+	if (tokenRecord.codeChallengeMethod === "s256") {
+		const codeChallenge = Buffer.from(base64Url.decode(tokenRecord.codeChallenge));
+		const codeVerifier = Buffer.from(await createHash("SHA-256").digest(ctx.body.code_verifier));
+		if (codeChallenge.length !== codeVerifier.length || !timingSafeEqual(codeChallenge, codeVerifier)) throw APIError.from("BAD_REQUEST", ELECTRON_ERROR_CODES.INVALID_CODE_VERIFIER);
+	} else if (tokenRecord.codeChallenge !== ctx.body.code_verifier) throw APIError.from("BAD_REQUEST", ELECTRON_ERROR_CODES.INVALID_CODE_VERIFIER);
+	await ctx.context.internalAdapter.deleteVerificationValue(token.id);
+	const user = await ctx.context.internalAdapter.findUserById(tokenRecord.userId);
+	if (!user) throw APIError.from("INTERNAL_SERVER_ERROR", BASE_ERROR_CODES.USER_NOT_FOUND);
+	const session = await ctx.context.internalAdapter.createSession(user.id);
+	if (!session) throw APIError.from("INTERNAL_SERVER_ERROR", BASE_ERROR_CODES.FAILED_TO_CREATE_SESSION);
+	await setSessionCookie(ctx, {
+		session,
+		user
+	});
+	return ctx.json({
+		token: session.token,
+		user: parseUserOutput(ctx.context.options, user)
+	});
+});
+const electronInitOAuthProxyQuerySchema = z.object({
+	provider: z.string().nonempty(),
+	state: z.string(),
+	code_challenge: z.string(),
+	code_challenge_method: z.string().optional()
+});
+const electronInitOAuthProxy = (opts) => createAuthEndpoint("/electron/init-oauth-proxy", {
+	method: "GET",
+	query: electronInitOAuthProxyQuerySchema,
+	metadata: { scope: "http" }
+}, async (ctx) => {
+	const isSocialProvider = SocialProviderListEnum.safeParse(ctx.query.provider);
+	if (!isSocialProvider && !ctx.context.getPlugin("generic-oauth")) throw APIError.from("BAD_REQUEST", BASE_ERROR_CODES.PROVIDER_NOT_FOUND);
+	const headers = new Headers(ctx.request?.headers);
+	headers.set("origin", new URL(ctx.context.baseURL).origin);
+	let setCookie = null;
+	const searchParams = new URLSearchParams();
+	searchParams.set("client_id", opts.clientID || "electron");
+	searchParams.set("code_challenge", ctx.query.code_challenge);
+	searchParams.set("code_challenge_method", ctx.query.code_challenge_method || "plain");
+	searchParams.set("state", ctx.query.state);
+	const res = await betterFetch(`${isSocialProvider ? "/sign-in/social" : "/sign-in/oauth2"}?${searchParams.toString()}`, {
+		baseURL: ctx.context.baseURL,
+		method: "POST",
+		body: {
+			provider: ctx.query.provider,
+			disableRedirect: true
+		},
+		onResponse: (ctx) => {
+			setCookie = ctx.response.headers.get("set-cookie") ?? null;
+		},
+		headers
+	});
+	if (res.error) throw new APIError("INTERNAL_SERVER_ERROR", { message: res.error.message || "An unknown error occurred." });
+	if (setCookie) ctx.setHeader("set-cookie", setCookie);
+	if (res.data.url) {
+		ctx.setHeader("Location", res.data.url);
+		ctx.setStatus(302);
+		return;
+	}
+	return ctx.json(res.data);
+});
+
+//#endregion
+//#region src/index.ts
+const electron = (options) => {
+	const opts = {
+		codeExpiresIn: 300,
+		redirectCookieExpiresIn: 120,
+		cookiePrefix: "better-auth",
+		clientID: "electron",
+		...options || {}
+	};
+	const hookMatcher = (ctx) => {
+		return !!(ctx.path?.startsWith("/sign-in") || ctx.path?.startsWith("/sign-up") || ctx.path?.startsWith("/callback") || ctx.path?.startsWith("/oauth2/callback") || ctx.path?.startsWith("/magic-link/verify") || ctx.path?.startsWith("/email-otp/verify-email") || ctx.path?.startsWith("/verify-email") || ctx.path?.startsWith("/one-tap/callback") || ctx.path?.startsWith("/passkey/verify-authentication") || ctx.path?.startsWith("/phone-number/verify"));
+	};
+	return {
+		id: "electron",
+		async onRequest(request, _ctx) {
+			if (opts.disableOriginOverride || request.headers.get("origin")) return;
+			const electronOrigin = request.headers.get("electron-origin");
+			if (!electronOrigin) return;
+			const req = request.clone();
+			req.headers.set("origin", electronOrigin);
+			return { request: req };
+		},
+		hooks: { after: [{
+			matcher: (ctx) => !hookMatcher(ctx),
+			handler: createAuthMiddleware(async (ctx) => {
+				const transferCookie = await ctx.getSignedCookie(`${opts.cookiePrefix}.transfer_token`, ctx.context.secret);
+				if (!ctx.context.newSession?.session || !transferCookie) return;
+				const cookie = ctx.context.createAuthCookie("transfer_token", { maxAge: opts.codeExpiresIn });
+				await ctx.setSignedCookie(cookie.name, transferCookie, ctx.context.secret, cookie.attributes);
+			})
+		}, {
+			matcher: hookMatcher,
+			handler: createAuthMiddleware(async (ctx) => {
+				const querySchema = z.object({
+					client_id: z.string(),
+					code_challenge: z.string().nonempty(),
+					code_challenge_method: z.string().optional().default("plain"),
+					state: z.string().nonempty()
+				});
+				const cookie = ctx.context.createAuthCookie("transfer_token", { maxAge: opts.codeExpiresIn });
+				if (ctx.query?.client_id === opts.clientID && (ctx.path.startsWith("/sign-in") || ctx.path.startsWith("/sign-up"))) {
+					const query = querySchema.safeParse(ctx.query);
+					if (query.success) await ctx.setSignedCookie(cookie.name, JSON.stringify(query.data), ctx.context.secret, cookie.attributes);
+				}
+				if (!ctx.context.newSession?.session) return;
+				const transferCookie = await ctx.getSignedCookie(cookie.name, ctx.context.secret);
+				ctx.setCookie(cookie.name, "", {
+					...cookie.attributes,
+					maxAge: 0
+				});
+				let transferPayload = null;
+				if (!!transferCookie) transferPayload = safeJSONParse(transferCookie);
+				else {
+					const query = querySchema.safeParse(ctx.query);
+					if (query.success) transferPayload = query.data;
+				}
+				if (!transferPayload) return;
+				const { client_id, code_challenge, code_challenge_method, state } = transferPayload;
+				if (client_id !== opts.clientID) return;
+				if (!state) throw APIError.from("BAD_REQUEST", ELECTRON_ERROR_CODES.MISSING_STATE);
+				if (!code_challenge) throw APIError.from("BAD_REQUEST", ELECTRON_ERROR_CODES.MISSING_PKCE);
+				const redirectCookieName = `${opts.cookiePrefix}.${opts.clientID}`;
+				const identifier = generateRandomString(32, "a-z", "A-Z", "0-9");
+				const codeExpiresInMs = opts.codeExpiresIn * 1e3;
+				const expiresAt = new Date(Date.now() + codeExpiresInMs);
+				await ctx.context.internalAdapter.createVerificationValue({
+					identifier: `electron:${identifier}`,
+					value: JSON.stringify({
+						userId: ctx.context.newSession.user.id,
+						codeChallenge: code_challenge,
+						codeChallengeMethod: code_challenge_method.toLowerCase(),
+						state
+					}),
+					expiresAt
+				});
+				ctx.setCookie(redirectCookieName, identifier, {
+					...ctx.context.authCookies.sessionToken.attributes,
+					maxAge: opts.redirectCookieExpiresIn,
+					httpOnly: false
+				});
+				return ctx;
+			})
+		}] },
+		endpoints: {
+			electronToken: electronToken(opts),
+			electronInitOAuthProxy: electronInitOAuthProxy(opts)
+		},
+		options: opts,
+		$ERROR_CODES: ELECTRON_ERROR_CODES
+	};
+};
+
+//#endregion
+export { electron };

package/dist/proxy.d.mts

@@ -0,0 +1,27 @@
+import { r as ElectronProxyClientOptions } from "./authenticate-CWAVJ4W8.mjs";
+
+//#region src/proxy.d.ts
+declare const electronProxyClient: (options: ElectronProxyClientOptions) => {
+  id: "electron-proxy";
+  getActions: () => {
+    /**
+     * Ensures redirecting to the Electron app.
+     *
+     * Polls for a cookie set by the server to indicate that an authorization code is available.
+     *
+     * @returns The interval ID which can be used to clear the polling.
+     */
+    ensureElectronRedirect: (cfg?: {
+      /**
+       * @default 10_000
+       */
+      timeout?: number | undefined;
+      /**
+       * @default 100
+       */
+      interval?: number | undefined;
+    } | undefined) => NodeJS.Timeout;
+  };
+};
+//#endregion
+export { electronProxyClient };

package/dist/proxy.mjs

@@ -0,0 +1,39 @@
+import { n as parseProtocolScheme } from "./utils-C3fLmbAT.mjs";
+import { parseCookies } from "better-auth/cookies";
+
+//#region src/proxy.ts
+const electronProxyClient = (options) => {
+	const opts = {
+		clientID: "electron",
+		cookiePrefix: "better-auth",
+		callbackPath: "/auth/callback",
+		...options
+	};
+	const redirectCookieName = `${opts.cookiePrefix}.${opts.clientID}`;
+	const { scheme } = parseProtocolScheme(opts.protocol);
+	return {
+		id: "electron-proxy",
+		getActions: () => {
+			return { ensureElectronRedirect: (cfg) => {
+				const timeout = cfg?.timeout || 1e4;
+				const interval = cfg?.interval || 100;
+				const handleRedirect = () => {
+					if (typeof document === "undefined") return false;
+					const authorizationCode = parseCookies(document.cookie).get(redirectCookieName);
+					if (!authorizationCode) return false;
+					document.cookie = `${redirectCookieName}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/`;
+					window.location.replace(`${scheme}:/${opts.callbackPath}#token=${authorizationCode}`);
+					return true;
+				};
+				const start = Date.now();
+				const id = setInterval(() => {
+					if (handleRedirect() || Date.now() - start > timeout) clearInterval(id);
+				}, interval);
+				return id;
+			} };
+		}
+	};
+};
+
+//#endregion
+export { electronProxyClient };

package/dist/storage.d.mts

@@ -0,0 +1,8 @@
+import { i as Storage } from "./authenticate-CWAVJ4W8.mjs";
+import "./client-BBp9yCmE.mjs";
+import { Options } from "conf";
+
+//#region src/storage.d.ts
+declare const storage: (opts?: Options<Record<string, any>> | undefined) => Storage;
+//#endregion
+export { storage };

package/dist/storage.mjs

@@ -0,0 +1,28 @@
+import electron from "electron";
+import Conf from "conf";
+
+//#region src/storage.ts
+const { app } = electron;
+const storage = (opts) => {
+	if (!app) return {
+		getItem: () => null,
+		setItem: () => {}
+	};
+	const config = new Conf({
+		cwd: app.getPath("userData"),
+		projectName: app.getName(),
+		projectVersion: app.getVersion(),
+		...opts
+	});
+	return {
+		getItem: (key) => {
+			return config.get(key, null);
+		},
+		setItem: (key, value) => {
+			config.set(key, value);
+		}
+	};
+};
+
+//#endregion
+export { storage };

package/dist/utils-C3fLmbAT.mjs

@@ -0,0 +1,17 @@
+//#region src/utils.ts
+function isProcessType(type) {
+	return typeof process !== "undefined" && process.type === type;
+}
+function parseProtocolScheme(protocolOption) {
+	if (typeof protocolOption === "string") return {
+		scheme: protocolOption,
+		privileges: {}
+	};
+	return {
+		scheme: protocolOption.scheme,
+		privileges: protocolOption.privileges || {}
+	};
+}
+
+//#endregion
+export { parseProtocolScheme as n, isProcessType as t };

package/package.json

@@ -0,0 +1,104 @@
+{
+  "name": "@better-auth/electron",
+  "version": "1.5.0-beta.12",
+  "type": "module",
+  "description": "Better Auth integration for Electron applications.",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/better-auth/better-auth",
+    "directory": "packages/electron"
+  },
+  "homepage": "https://www.better-auth.com/docs/integrations/electron",
+  "keywords": [
+    "electron",
+    "auth",
+    "better-auth",
+    "typescript"
+  ],
+  "exports": {
+    ".": {
+      "dev-source": "./src/index.ts",
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./client": {
+      "dev-source": "./src/client.ts",
+      "types": "./dist/client.d.mts",
+      "default": "./dist/client.mjs"
+    },
+    "./proxy": {
+      "dev-source": "./src/proxy.ts",
+      "types": "./dist/proxy.d.mts",
+      "default": "./dist/proxy.mjs"
+    },
+    "./storage": {
+      "dev-source": "./src/storage.ts",
+      "types": "./dist/storage.d.mts",
+      "default": "./dist/storage.mjs"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/index.d.mts"
+      ],
+      "client": [
+        "./dist/client.d.mts"
+      ],
+      "proxy": [
+        "./dist/proxy.d.mts"
+      ],
+      "storage": [
+        "./dist/storage.d.mts"
+      ]
+    }
+  },
+  "peerDependenciesMeta": {
+    "electron": {
+      "optional": true
+    },
+    "conf": {
+      "optional": true
+    }
+  },
+  "peerDependencies": {
+    "@better-auth/utils": "0.3.1",
+    "@better-fetch/fetch": "1.1.21",
+    "better-call": "1.2.1",
+    "conf": "^15.0.2",
+    "@better-auth/core": "1.5.0-beta.12",
+    "better-auth": "1.5.0-beta.12"
+  },
+  "dependencies": {
+    "zod": "^4.3.5"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "better-sqlite3": "^12.6.2",
+    "tsdown": "^0.20.1",
+    "@better-auth/core": "1.5.0-beta.12",
+    "better-auth": "1.5.0-beta.12"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "vitest",
+    "coverage": "vitest run --coverage --coverage.provider=istanbul",
+    "lint:package": "publint run --strict",
+    "lint:types": "attw --profile esm-only --pack .",
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --project tsconfig.json"
+  }
+}