@better-auth/electron 1.6.26 → 1.6.28

package/dist/{client-Dfn6XsLf.d.mts → client-D1E7e0Mq.d.mts}

@@ -1,9 +1,12 @@
+import * as _$better_auth0 from "better-auth";
 import { ClientStore } from "better-auth";
 import * as z from "zod";
+import * as _$_better_fetch_fetch0 from "@better-fetch/fetch";
 import { BetterFetch, BetterFetchError, CreateFetchOption } from "@better-fetch/fetch";
 import electron from "electron";
 import { Awaitable, BetterAuthClientOptions } from "@better-auth/core";
 import { User } from "@better-auth/core/db";
+
 //#region src/types/options.d.ts
 interface ElectronSharedOptions {
   /**
@@ -259,7 +262,13 @@ interface ElectronAuthenticateOptions {
 /**
  * Exchanges the authorization code for a session.
  */
-declare function authenticate({ $fetch, options, token, getWindow, fetchOptions }: ElectronAuthenticateOptions & {
+declare function authenticate({
+  $fetch,
+  options,
+  token,
+  getWindow,
+  fetchOptions
+}: ElectronAuthenticateOptions & {
   $fetch: BetterFetch;
   options: ElectronClientOptions;
   getWindow: () => Electron.BrowserWindow | null | undefined;
@@ -288,7 +297,13 @@ type SetupMainConfig = {
 /**
  * Handles the deep link URL for authentication.
  */
-declare function handleDeepLink({ $fetch, options, url, getWindow, clientOptions }: {
+declare function handleDeepLink({
+  $fetch,
+  options,
+  url,
+  getWindow,
+  clientOptions
+}: {
   $fetch: BetterFetch;
   options: ElectronClientOptions;
   url: string;
@@ -316,17 +331,17 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
       referrerPolicy?: ReferrerPolicy | undefined;
       signal?: (AbortSignal | null) | undefined;
       window?: null | undefined;
-      onRequest?: (<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>) => Promise<import("@better-fetch/fetch").RequestContext | void> | import("@better-fetch/fetch").RequestContext | void) | undefined;
-      onResponse?: ((context: import("@better-fetch/fetch").ResponseContext) => Promise<Response | void | import("@better-fetch/fetch").ResponseContext> | Response | import("@better-fetch/fetch").ResponseContext | void) | undefined;
-      onSuccess?: ((context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void> | void) | undefined;
-      onError?: ((context: import("@better-fetch/fetch").ErrorContext) => Promise<void> | void) | undefined;
-      onRetry?: ((response: import("@better-fetch/fetch").ResponseContext) => Promise<void> | void) | undefined;
+      onRequest?: (<T extends Record<string, any>>(context: _$_better_fetch_fetch0.RequestContext<T>) => Promise<_$_better_fetch_fetch0.RequestContext | void> | _$_better_fetch_fetch0.RequestContext | void) | undefined;
+      onResponse?: ((context: _$_better_fetch_fetch0.ResponseContext) => Promise<Response | void | _$_better_fetch_fetch0.ResponseContext> | Response | _$_better_fetch_fetch0.ResponseContext | void) | undefined;
+      onSuccess?: ((context: _$_better_fetch_fetch0.SuccessContext<any>) => Promise<void> | void) | undefined;
+      onError?: ((context: _$_better_fetch_fetch0.ErrorContext) => Promise<void> | void) | undefined;
+      onRetry?: ((response: _$_better_fetch_fetch0.ResponseContext) => Promise<void> | void) | undefined;
       hookOptions?: {
         cloneResponse?: boolean;
       } | undefined;
       timeout?: number | undefined;
-      customFetchImpl?: import("@better-fetch/fetch").FetchEsque | undefined;
-      plugins?: import("@better-fetch/fetch").BetterFetchPlugin[] | undefined;
+      customFetchImpl?: _$_better_fetch_fetch0.FetchEsque | undefined;
+      plugins?: _$_better_fetch_fetch0.BetterFetchPlugin[] | undefined;
       baseURL?: string | undefined;
       throw?: boolean | undefined;
       auth?: ({
@@ -352,10 +367,10 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
       params?: any;
       duplex?: "full" | "half" | undefined;
       jsonParser?: ((text: string) => Promise<any> | any) | undefined;
-      retry?: import("@better-fetch/fetch").RetryOptions | undefined;
+      retry?: _$_better_fetch_fetch0.RetryOptions | undefined;
       retryAttempt?: number | undefined;
-      output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
-      errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
+      output?: (_$_better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+      errorSchema?: _$_better_fetch_fetch0.StandardSchemaV1 | undefined;
       disableValidation?: boolean | undefined;
     } & Record<string, any>) | undefined): Promise<{
       url: string;
@@ -372,17 +387,17 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
         referrerPolicy?: ReferrerPolicy | undefined;
         signal?: (AbortSignal | null) | undefined;
         window?: null | undefined;
-        onRequest?: (<T extends Record<string, any>>(context: import("@better-fetch/fetch").RequestContext<T>) => Promise<import("@better-fetch/fetch").RequestContext | void> | import("@better-fetch/fetch").RequestContext | void) | undefined;
-        onResponse?: ((context: import("@better-fetch/fetch").ResponseContext) => Promise<Response | void | import("@better-fetch/fetch").ResponseContext> | Response | import("@better-fetch/fetch").ResponseContext | void) | undefined;
-        onSuccess?: ((context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void> | void) | undefined;
-        onError?: ((context: import("@better-fetch/fetch").ErrorContext) => Promise<void> | void) | undefined;
-        onRetry?: ((response: import("@better-fetch/fetch").ResponseContext) => Promise<void> | void) | undefined;
+        onRequest?: (<T extends Record<string, any>>(context: _$_better_fetch_fetch0.RequestContext<T>) => Promise<_$_better_fetch_fetch0.RequestContext | void> | _$_better_fetch_fetch0.RequestContext | void) | undefined;
+        onResponse?: ((context: _$_better_fetch_fetch0.ResponseContext) => Promise<Response | void | _$_better_fetch_fetch0.ResponseContext> | Response | _$_better_fetch_fetch0.ResponseContext | void) | undefined;
+        onSuccess?: ((context: _$_better_fetch_fetch0.SuccessContext<any>) => Promise<void> | void) | undefined;
+        onError?: ((context: _$_better_fetch_fetch0.ErrorContext) => Promise<void> | void) | undefined;
+        onRetry?: ((response: _$_better_fetch_fetch0.ResponseContext) => Promise<void> | void) | undefined;
         hookOptions?: {
           cloneResponse?: boolean;
         } | undefined;
         timeout?: number | undefined;
-        customFetchImpl?: import("@better-fetch/fetch").FetchEsque | undefined;
-        plugins?: import("@better-fetch/fetch").BetterFetchPlugin[] | undefined;
+        customFetchImpl?: _$_better_fetch_fetch0.FetchEsque | undefined;
+        plugins?: _$_better_fetch_fetch0.BetterFetchPlugin[] | undefined;
         baseURL?: string | undefined;
         throw?: boolean | undefined;
         auth?: ({
@@ -408,19 +423,19 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
         params?: any;
         duplex?: "full" | "half" | undefined;
         jsonParser?: ((text: string) => Promise<any> | any) | undefined;
-        retry?: import("@better-fetch/fetch").RetryOptions | undefined;
+        retry?: _$_better_fetch_fetch0.RetryOptions | undefined;
         retryAttempt?: number | undefined;
-        output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
-        errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
+        output?: (_$_better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+        errorSchema?: _$_better_fetch_fetch0.StandardSchemaV1 | undefined;
         disableValidation?: boolean | undefined;
       } & Record<string, any>;
     }>;
     hooks: {
-      onSuccess: (context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void>;
-      onError: (context: import("@better-fetch/fetch").ErrorContext) => Promise<void>;
+      onSuccess: (context: _$_better_fetch_fetch0.SuccessContext<any>) => Promise<void>;
+      onError: (context: _$_better_fetch_fetch0.ErrorContext) => Promise<void>;
     };
   }[];
-  getActions: ($fetch: import("@better-fetch/fetch").BetterFetch, $store: ClientStore, clientOptions: import("better-auth").BetterAuthClientOptions | undefined) => {
+  getActions: ($fetch: _$_better_fetch_fetch0.BetterFetch, $store: ClientStore, clientOptions: _$better_auth0.BetterAuthClientOptions | undefined) => {
     /**
      * Gets the stored cookie.
      *
@@ -458,7 +473,7 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
     } | {
       data: {
         token: string;
-        user: import("better-auth").User & Record<string, any>;
+        user: _$better_auth0.User & Record<string, any>;
       };
       error: null;
     }>;

package/dist/client.d.mts

@@ -1,2 +1,2 @@
-import { _ as setupRenderer, a as authenticate, c as ElectronClientOptions, d as Storage, f as FetchUserImageResult, g as SetupRendererConfig, h as ExposedBridges, i as ElectronRequestAuthOptions, l as ElectronProxyClientOptions, m as normalizeUserOutput, n as handleDeepLink, o as kElectron, p as fetchUserImage, r as ElectronAuthenticateOptions, s as requestAuth, t as electronClient, u as ElectronSharedClientOptions, y as ElectronSharedOptions } from "./client-Dfn6XsLf.mjs";
-export { type ElectronAuthenticateOptions, type ElectronClientOptions, type ElectronProxyClientOptions, type ElectronRequestAuthOptions, type ElectronSharedClientOptions, type ElectronSharedOptions, type ExposedBridges, type FetchUserImageResult, type SetupRendererConfig, type Storage, type authenticate, electronClient, type fetchUserImage, handleDeepLink, type kElectron, normalizeUserOutput, type requestAuth, type setupRenderer };
+import { _ as setupRenderer, a as authenticate, c as ElectronClientOptions, d as Storage, f as FetchUserImageResult, g as SetupRendererConfig, h as ExposedBridges, i as ElectronRequestAuthOptions, l as ElectronProxyClientOptions, m as normalizeUserOutput, n as handleDeepLink, o as kElectron, p as fetchUserImage, r as ElectronAuthenticateOptions, s as requestAuth, t as electronClient, u as ElectronSharedClientOptions, y as ElectronSharedOptions } from "./client-D1E7e0Mq.mjs";
+export { ElectronAuthenticateOptions, ElectronClientOptions, ElectronProxyClientOptions, ElectronRequestAuthOptions, ElectronSharedClientOptions, ElectronSharedOptions, ExposedBridges, FetchUserImageResult, SetupRendererConfig, Storage, authenticate, electronClient, fetchUserImage, handleDeepLink, kElectron, normalizeUserOutput, requestAuth, setupRenderer };

package/dist/client.mjs

@@ -1,5 +1,5 @@
-import { t as PACKAGE_VERSION } from "./version-CPj5-4mL.mjs";
-import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-C5XBRvIU.mjs";
+import { t as PACKAGE_VERSION } from "./version-6ZHwEASO.mjs";
+import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-DxDKRT6e.mjs";
 import { BetterAuthError } from "@better-auth/core/error";
 import { base64, base64Url } from "@better-auth/utils/base64";
 import { APIError as APIError$1, getBaseURL, isDevelopment, isTest, safeJSONParse } from "better-auth";
@@ -578,7 +578,7 @@ const electronClient = (options) => {
 	let store = null;
 	const cookieName = `${opts.storagePrefix}.cookie`;
 	const localCacheName = `${opts.storagePrefix}.local_cache`;
-	const { getDecrypted, setEncrypted } = storageAdapter(opts.storage, /* @__PURE__ */ new Set([cookieName, localCacheName]));
+	const { getDecrypted, setEncrypted } = storageAdapter(opts.storage, new Set([cookieName, localCacheName]));
 	const clearSessionCache = () => {
 		setEncrypted(cookieName, "{}");
 		store?.atoms.session?.set({

package/dist/index.d.mts

@@ -1,6 +1,10 @@
-import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-Dfn6XsLf.mjs";
+import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-D1E7e0Mq.mjs";
+import * as _$better_auth0 from "better-auth";
 import * as z from "zod";
+import * as _$_better_auth_core0 from "@better-auth/core";
 import { HookEndpointContext } from "@better-auth/core";
+import * as _$better_call0 from "better-call";
+
 //#region src/index.d.ts
 declare module "@better-auth/core" {
   interface BetterAuthPluginRegistry<AuthOptions, Options> {
@@ -12,20 +16,17 @@ declare module "@better-auth/core" {
 declare const electron: (options?: ElectronOptions | undefined) => {
   id: "electron";
   version: string;
-  onRequest(request: Request, _ctx: import("better-auth").AuthContext): Promise<{
+  onRequest(request: Request, _ctx: _$better_auth0.AuthContext): Promise<{
     request: Request;
   } | undefined>;
   hooks: {
     after: ({
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
+      handler: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<void>>;
     } | {
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<import("better-call").MiddlewareContext<import("better-call").MiddlewareOptions, {
-        returned?: unknown | undefined;
-        responseHeaders?: Headers | undefined;
-      } & import("better-auth").PluginContext<import("better-auth").BetterAuthOptions> & import("better-auth").InfoContext & {
-        options: import("better-auth").BetterAuthOptions;
+      handler: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<_$better_call0.MiddlewareContext<_$better_call0.MiddlewareOptions, _$better_auth0.PluginContext<_$better_auth0.BetterAuthOptions> & _$better_auth0.InfoContext & {
+        options: _$better_auth0.BetterAuthOptions;
         trustedOrigins: string[];
         trustedProviders: string[];
         isTrustedOrigin: (url: string, settings?: {
@@ -98,20 +99,20 @@ declare const electron: (options?: ElectronOptions | undefined) => {
             image?: string | null | undefined;
           } & Record<string, any>;
         } | null) => void;
-        socialProviders: import("better-auth").OAuthProvider[];
-        authCookies: import("better-auth").BetterAuthCookies;
-        logger: ReturnType<typeof import("better-auth").createLogger>;
+        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<import("better-auth").BetterAuthRateLimitOptions, "enabled" | "window" | "max" | "storage">;
-        adapter: import("better-auth").DBAdapter<import("better-auth").BetterAuthOptions>;
-        internalAdapter: import("better-auth").InternalAdapter<import("better-auth").BetterAuthOptions>;
-        createAuthCookie: (cookieName: string, overrideAttributes?: Partial<import("better-call").CookieOptions> | undefined) => import("better-auth").BetterAuthCookie;
+        } & 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;
-        secretConfig: string | import("better-auth").SecretConfig;
+        secretConfig: string | _$better_auth0.SecretConfig;
         sessionConfig: {
           updateAge: number;
           expiresIn: number;
@@ -122,10 +123,10 @@ declare const electron: (options?: ElectronOptions | undefined) => {
           };
         };
         generateId: (options: {
-          model: import("better-auth").ModelNames;
+          model: _$better_auth0.ModelNames;
           size?: number | undefined;
         }) => string | false;
-        secondaryStorage: import("better-auth").SecondaryStorage | undefined;
+        secondaryStorage: _$better_auth0.SecondaryStorage | undefined;
         password: {
           hash: (password: string) => Promise<string>;
           verify: (data: {
@@ -136,9 +137,9 @@ declare const electron: (options?: ElectronOptions | undefined) => {
             minPasswordLength: number;
             maxPasswordLength: number;
           };
-          checkPassword: (userId: string, ctx: import("@better-auth/core").GenericEndpointContext<import("better-auth").BetterAuthOptions>) => Promise<boolean>;
+          checkPassword: (userId: string, ctx: _$_better_auth_core0.GenericEndpointContext<_$better_auth0.BetterAuthOptions>) => Promise<boolean>;
         };
-        tables: import("better-auth").BetterAuthDBSchema;
+        tables: _$better_auth0.BetterAuthDBSchema;
         runMigrations: () => Promise<void>;
         publishTelemetry: (event: {
           type: string;
@@ -148,14 +149,17 @@ declare const electron: (options?: ElectronOptions | undefined) => {
         skipOriginCheck: boolean | string[];
         skipCSRFCheck: boolean;
         runInBackground: (promise: Promise<unknown>) => void;
-        runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("better-auth").Awaitable<unknown>;
+        runInBackgroundOrAwait: (promise: Promise<unknown> | void) => _$better_auth0.Awaitable<unknown>;
+      } & {
+        returned?: unknown | undefined;
+        responseHeaders?: Headers | undefined;
       }> | {
         electron_authorization_code: string;
-      } | undefined>;
+      } | undefined>>;
     })[];
   };
   endpoints: {
-    electronToken: import("better-call").StrictEndpoint<"/electron/token", {
+    electronToken: _$better_call0.StrictEndpoint<"/electron/token", {
       method: "POST";
       body: z.ZodObject<{
         token: z.ZodString;
@@ -193,9 +197,9 @@ declare const electron: (options?: ElectronOptions | undefined) => {
       };
     }, {
       token: string;
-      user: import("better-auth").User & Record<string, any>;
+      user: _$better_auth0.User & Record<string, any>;
     }>;
-    electronInitOAuthProxy: import("better-call").StrictEndpoint<"/electron/init-oauth-proxy", {
+    electronInitOAuthProxy: _$better_call0.StrictEndpoint<"/electron/init-oauth-proxy", {
       method: "GET";
       query: z.ZodObject<{
         provider: z.ZodString;
@@ -242,10 +246,10 @@ declare const electron: (options?: ElectronOptions | undefined) => {
     }, {
       url: string | undefined;
       redirect: boolean;
-      user?: import("better-auth").User & Record<string, any>;
+      user?: _$better_auth0.User & Record<string, any>;
       token?: string;
     } | undefined>;
-    electronTransferUser: import("better-call").StrictEndpoint<"/electron/transfer-user", {
+    electronTransferUser: _$better_call0.StrictEndpoint<"/electron/transfer-user", {
       method: "POST";
       query: z.ZodObject<{
         client_id: z.ZodString;
@@ -256,7 +260,7 @@ declare const electron: (options?: ElectronOptions | undefined) => {
       body: z.ZodObject<{
         callbackURL: z.ZodOptional<z.ZodString>;
       }, z.core.$strip>;
-      use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
+      use: _$better_call0.Middleware<_$better_call0.MiddlewareOptions, (inputContext: _$better_call0.MiddlewareInputContext<_$better_call0.MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -278,7 +282,7 @@ declare const electron: (options?: ElectronOptions | undefined) => {
             image?: string | null | undefined;
           };
         };
-      }>)[];
+      }>>[];
       requireHeaders: true;
       metadata: {
         openapi: {
@@ -325,15 +329,15 @@ declare const electron: (options?: ElectronOptions | undefined) => {
     clientID: string;
   };
   $ERROR_CODES: {
-    INVALID_TOKEN: import("better-auth").RawError<"INVALID_TOKEN">;
-    INVALID_CLIENT_ID: import("better-auth").RawError<"INVALID_CLIENT_ID">;
-    STATE_MISMATCH: import("better-auth").RawError<"STATE_MISMATCH">;
-    MISSING_CODE_CHALLENGE: import("better-auth").RawError<"MISSING_CODE_CHALLENGE">;
-    INVALID_CODE_VERIFIER: import("better-auth").RawError<"INVALID_CODE_VERIFIER">;
-    MISSING_STATE: import("better-auth").RawError<"MISSING_STATE">;
-    MISSING_PKCE: import("better-auth").RawError<"MISSING_PKCE">;
-    INVALID_PKCE_METHOD: import("better-auth").RawError<"INVALID_PKCE_METHOD">;
+    INVALID_TOKEN: _$better_auth0.RawError<"INVALID_TOKEN">;
+    INVALID_CLIENT_ID: _$better_auth0.RawError<"INVALID_CLIENT_ID">;
+    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">;
+    INVALID_PKCE_METHOD: _$better_auth0.RawError<"INVALID_PKCE_METHOD">;
   };
 };
 //#endregion
-export { type ElectronOptions, type ElectronSharedOptions, type FetchUserImageResult, electron, type fetchUserImage, type normalizeUserOutput };
+export { ElectronOptions, ElectronSharedOptions, FetchUserImageResult, electron, fetchUserImage, normalizeUserOutput };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "./version-CPj5-4mL.mjs";
+import { t as PACKAGE_VERSION } from "./version-6ZHwEASO.mjs";
 import { createAuthMiddleware } from "@better-auth/core/api";
 import { APIError, BASE_ERROR_CODES } from "@better-auth/core/error";
 import { base64Url } from "@better-auth/utils/base64";

package/dist/preload.d.mts

@@ -1,9 +1,7 @@
-import electron from "electron";
 import { Awaitable } from "@better-auth/core";
 import { User } from "@better-auth/core/db";
 import { BetterFetchError } from "@better-fetch/fetch";
 import * as z from "zod";
-import "better-auth";
 //#region src/types/options.d.ts
 interface ElectronSharedOptions {
   /**

package/dist/preload.mjs

@@ -1,5 +1,5 @@
 import electron, { contextBridge } from "electron";
-//#region ../../node_modules/.pnpm/better-call@1.3.7_zod@4.3.6/node_modules/better-call/dist/error.mjs
+//#region ../../node_modules/.pnpm/better-call@1.4.0_zod@4.3.6/node_modules/better-call/dist/error.mjs
 function isErrorStackTraceLimitWritable() {
 	const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
 	if (desc === void 0) return Object.isExtensible(Error);
@@ -96,6 +96,10 @@ const statusCodes = {
 	NETWORK_AUTHENTICATION_REQUIRED: 511
 };
 var InternalAPIError = class extends Error {
+	status;
+	body;
+	headers;
+	statusCode;
 	constructor(status = "INTERNAL_SERVER_ERROR", body = void 0, headers = {}, statusCode = typeof status === "number" ? status : statusCodes[status]) {
 		super(body?.message, body?.cause ? { cause: body.cause } : void 0);
 		this.status = status;

package/dist/proxy.d.mts

@@ -1,5 +1,6 @@
-import { l as ElectronProxyClientOptions } from "./client-Dfn6XsLf.mjs";
+import { l as ElectronProxyClientOptions } from "./client-D1E7e0Mq.mjs";
 import { electron } from "./index.mjs";
+
 //#region src/proxy.d.ts
 declare const electronProxyClient: (options: ElectronProxyClientOptions) => {
   id: "electron-proxy";

package/dist/proxy.mjs

@@ -1,5 +1,5 @@
-import { t as PACKAGE_VERSION } from "./version-CPj5-4mL.mjs";
-import { r as parseProtocolScheme } from "./utils-C5XBRvIU.mjs";
+import { t as PACKAGE_VERSION } from "./version-6ZHwEASO.mjs";
+import { r as parseProtocolScheme } from "./utils-DxDKRT6e.mjs";
 import { parseCookies } from "better-auth/cookies";
 //#region src/proxy.ts
 const electronProxyClient = (options) => {

package/dist/storage.d.mts

@@ -1,5 +1,6 @@
-import { d as Storage } from "./client-Dfn6XsLf.mjs";
+import { d as Storage } from "./client-D1E7e0Mq.mjs";
 import { Options } from "conf";
+
 //#region src/storage.d.ts
 declare const storage: (opts?: Options<Record<string, any>> | undefined) => Storage;
 //#endregion

package/dist/{version-CPj5-4mL.mjs → version-6ZHwEASO.mjs}

@@ -1,5 +1,5 @@
 //#endregion
 //#region src/version.ts
-const PACKAGE_VERSION = "1.6.26";
+const PACKAGE_VERSION = "1.6.28";
 //#endregion
 export { PACKAGE_VERSION as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@better-auth/electron",
-  "version": "1.6.26",
+  "version": "1.6.28",
   "description": "Better Auth integration for Electron applications.",
   "type": "module",
   "license": "MIT",
@@ -79,18 +79,18 @@
     "@types/better-sqlite3": "^7.6.13",
     "better-sqlite3": "^12.6.2",
     "electron": "^43.1.1",
-    "tsdown": "0.22.7",
-    "@better-auth/core": "1.6.26",
-    "better-auth": "1.6.26"
+    "tsdown": "0.21.10",
+    "@better-auth/core": "1.6.28",
+    "better-auth": "1.6.28"
   },
   "peerDependencies": {
     "@better-auth/utils": "0.4.2",
     "@better-fetch/fetch": "1.3.1",
-    "better-call": "1.3.7",
+    "better-call": "1.4.0",
     "conf": "^15.0.2",
     "electron": ">=36.0.0",
-    "@better-auth/core": "^1.6.26",
-    "better-auth": "^1.6.26"
+    "@better-auth/core": "^1.6.28",
+    "better-auth": "^1.6.28"
   },
   "peerDependenciesMeta": {
     "electron": {