@better-auth/electron 1.6.22 → 1.6.24

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

@@ -1,12 +1,9 @@
-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 {
   /**
@@ -262,13 +259,7 @@ 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;
@@ -297,13 +288,7 @@ 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;
@@ -331,17 +316,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: _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;
+      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;
       hookOptions?: {
         cloneResponse?: boolean;
       } | undefined;
       timeout?: number | undefined;
-      customFetchImpl?: _better_fetch_fetch0.FetchEsque | undefined;
-      plugins?: _better_fetch_fetch0.BetterFetchPlugin[] | undefined;
+      customFetchImpl?: import("@better-fetch/fetch").FetchEsque | undefined;
+      plugins?: import("@better-fetch/fetch").BetterFetchPlugin[] | undefined;
       baseURL?: string | undefined;
       throw?: boolean | undefined;
       auth?: ({
@@ -367,10 +352,10 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
       params?: any;
       duplex?: "full" | "half" | undefined;
       jsonParser?: ((text: string) => Promise<any> | any) | undefined;
-      retry?: _better_fetch_fetch0.RetryOptions | undefined;
+      retry?: import("@better-fetch/fetch").RetryOptions | undefined;
       retryAttempt?: number | undefined;
-      output?: (_better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File) | undefined;
-      errorSchema?: _better_fetch_fetch0.StandardSchemaV1 | undefined;
+      output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+      errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
       disableValidation?: boolean | undefined;
     } & Record<string, any>) | undefined): Promise<{
       url: string;
@@ -387,17 +372,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: _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;
+        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;
         hookOptions?: {
           cloneResponse?: boolean;
         } | undefined;
         timeout?: number | undefined;
-        customFetchImpl?: _better_fetch_fetch0.FetchEsque | undefined;
-        plugins?: _better_fetch_fetch0.BetterFetchPlugin[] | undefined;
+        customFetchImpl?: import("@better-fetch/fetch").FetchEsque | undefined;
+        plugins?: import("@better-fetch/fetch").BetterFetchPlugin[] | undefined;
         baseURL?: string | undefined;
         throw?: boolean | undefined;
         auth?: ({
@@ -423,19 +408,19 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
         params?: any;
         duplex?: "full" | "half" | undefined;
         jsonParser?: ((text: string) => Promise<any> | any) | undefined;
-        retry?: _better_fetch_fetch0.RetryOptions | undefined;
+        retry?: import("@better-fetch/fetch").RetryOptions | undefined;
         retryAttempt?: number | undefined;
-        output?: (_better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File) | undefined;
-        errorSchema?: _better_fetch_fetch0.StandardSchemaV1 | undefined;
+        output?: (import("@better-fetch/fetch").StandardSchemaV1 | typeof Blob | typeof File) | undefined;
+        errorSchema?: import("@better-fetch/fetch").StandardSchemaV1 | undefined;
         disableValidation?: boolean | undefined;
       } & Record<string, any>;
     }>;
     hooks: {
-      onSuccess: (context: _better_fetch_fetch0.SuccessContext<any>) => Promise<void>;
-      onError: (context: _better_fetch_fetch0.ErrorContext) => Promise<void>;
+      onSuccess: (context: import("@better-fetch/fetch").SuccessContext<any>) => Promise<void>;
+      onError: (context: import("@better-fetch/fetch").ErrorContext) => Promise<void>;
     };
   }[];
-  getActions: ($fetch: _better_fetch_fetch0.BetterFetch, $store: ClientStore, clientOptions: better_auth0.BetterAuthClientOptions | undefined) => {
+  getActions: ($fetch: import("@better-fetch/fetch").BetterFetch, $store: ClientStore, clientOptions: import("better-auth").BetterAuthClientOptions | undefined) => {
     /**
      * Gets the stored cookie.
      *
@@ -473,7 +458,7 @@ declare const electronClient: <O extends ElectronClientOptions>(options: O) => {
     } | {
       data: {
         token: string;
-        user: better_auth0.User & Record<string, any>;
+        user: import("better-auth").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-hpd3q6M8.mjs";
-export { ElectronAuthenticateOptions, ElectronClientOptions, ElectronProxyClientOptions, ElectronRequestAuthOptions, ElectronSharedClientOptions, ElectronSharedOptions, ExposedBridges, FetchUserImageResult, SetupRendererConfig, Storage, authenticate, electronClient, fetchUserImage, handleDeepLink, kElectron, normalizeUserOutput, requestAuth, 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-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 };

package/dist/client.mjs

@@ -1,5 +1,5 @@
-import { t as PACKAGE_VERSION } from "./version-CD3Z0v2C.mjs";
-import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-DxDKRT6e.mjs";
+import { t as PACKAGE_VERSION } from "./version-DsNmK8I4.mjs";
+import { n as isProcessType, r as parseProtocolScheme, t as getChannelPrefixWithDelimiter } from "./utils-C5XBRvIU.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, new Set([cookieName, localCacheName]));
+	const { getDecrypted, setEncrypted } = storageAdapter(opts.storage, /* @__PURE__ */ new Set([cookieName, localCacheName]));
 	const clearSessionCache = () => {
 		setEncrypted(cookieName, "{}");
 		store?.atoms.session?.set({
@@ -648,7 +648,33 @@ const electronClient = (options) => {
 				return getCookie(getDecrypted(cookieName) || "{}");
 			};
 			return {
+				/**
+				* Gets the stored cookie.
+				*
+				* You can use this to get the cookie stored in
+				* the device and use it in your fetch requests.
+				*
+				* @example
+				* ```ts
+				* const cookie = client.getCookie();
+				* await fetch("https://api.example.com", {
+				*   headers: {
+				*    cookie,
+				*   },
+				* });
+				* ```
+				*/
 				getCookie: getCookieFn,
+				/**
+				* Exchanges the authorization code for a session.
+				*
+				* Use this when you need to manually complete the exchange
+				* (e.g., when another app registered the scheme or deep linking fails).
+				*
+				* The authorization code is returned when the user is authorized in the browser. (`electron_authorization_code`)
+				*
+				* Note: Must be called after `requestAuth`, since the code verifier and state are stored when the auth flow is initiated.
+				*/
 				authenticate: async (data) => {
 					return await authenticate({
 						...data,
@@ -657,7 +683,18 @@ const electronClient = (options) => {
 						getWindow: withGetWindowFallback(getWindow)
 					});
 				},
+				/**
+				* Initiates the authentication process.
+				* Opens the system's default browser for user authentication.
+				*/
 				requestAuth: (options) => requestAuth(clientOptions, opts, options),
+				/**
+				* Sets up the main process.
+				*
+				* - Registers custom protocol scheme.
+				* - Registers IPC bridge handlers.
+				* - Handles content security policy if needed.
+				*/
 				setupMain: (cfg) => {
 					if (cfg?.getWindow) getWindow = cfg.getWindow;
 					return setupMain($fetch, store, getCookieFn, opts, clientOptions, cfg);

package/dist/index.d.mts

@@ -1,10 +1,6 @@
-import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-hpd3q6M8.mjs";
-import * as better_auth0 from "better-auth";
+import { f as FetchUserImageResult, m as normalizeUserOutput, p as fetchUserImage, v as ElectronOptions, y as ElectronSharedOptions } from "./client-Dfn6XsLf.mjs";
 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> {
@@ -16,20 +12,20 @@ declare module "@better-auth/core" {
 declare const electron: (options?: ElectronOptions | undefined) => {
   id: "electron";
   version: string;
-  onRequest(request: Request, _ctx: better_auth0.AuthContext): Promise<{
+  onRequest(request: Request, _ctx: import("better-auth").AuthContext): Promise<{
     request: Request;
   } | undefined>;
   hooks: {
     after: ({
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<void>;
+      handler: (inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<void>;
     } | {
       matcher: (ctx: HookEndpointContext) => boolean;
-      handler: (inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<better_call0.MiddlewareContext<better_call0.MiddlewareOptions, {
+      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;
-      } & better_auth0.PluginContext<better_auth0.BetterAuthOptions> & better_auth0.InfoContext & {
-        options: better_auth0.BetterAuthOptions;
+      } & import("better-auth").PluginContext<import("better-auth").BetterAuthOptions> & import("better-auth").InfoContext & {
+        options: import("better-auth").BetterAuthOptions;
         trustedOrigins: string[];
         trustedProviders: string[];
         isTrustedOrigin: (url: string, settings?: {
@@ -102,20 +98,20 @@ declare const electron: (options?: ElectronOptions | undefined) => {
             image?: string | null | undefined;
           } & Record<string, any>;
         } | null) => void;
-        socialProviders: better_auth0.OAuthProvider[];
-        authCookies: better_auth0.BetterAuthCookies;
-        logger: ReturnType<typeof better_auth0.createLogger>;
+        socialProviders: import("better-auth").OAuthProvider[];
+        authCookies: import("better-auth").BetterAuthCookies;
+        logger: ReturnType<typeof import("better-auth").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;
+        } & 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;
         secret: string;
-        secretConfig: string | better_auth0.SecretConfig;
+        secretConfig: string | import("better-auth").SecretConfig;
         sessionConfig: {
           updateAge: number;
           expiresIn: number;
@@ -126,10 +122,10 @@ declare const electron: (options?: ElectronOptions | undefined) => {
           };
         };
         generateId: (options: {
-          model: better_auth0.ModelNames;
+          model: import("better-auth").ModelNames;
           size?: number | undefined;
         }) => string | false;
-        secondaryStorage: better_auth0.SecondaryStorage | undefined;
+        secondaryStorage: import("better-auth").SecondaryStorage | undefined;
         password: {
           hash: (password: string) => Promise<string>;
           verify: (data: {
@@ -140,9 +136,9 @@ declare const electron: (options?: ElectronOptions | undefined) => {
             minPasswordLength: number;
             maxPasswordLength: number;
           };
-          checkPassword: (userId: string, ctx: _better_auth_core0.GenericEndpointContext<better_auth0.BetterAuthOptions>) => Promise<boolean>;
+          checkPassword: (userId: string, ctx: import("@better-auth/core").GenericEndpointContext<import("better-auth").BetterAuthOptions>) => Promise<boolean>;
         };
-        tables: better_auth0.BetterAuthDBSchema;
+        tables: import("better-auth").BetterAuthDBSchema;
         runMigrations: () => Promise<void>;
         publishTelemetry: (event: {
           type: string;
@@ -152,14 +148,14 @@ declare const electron: (options?: ElectronOptions | undefined) => {
         skipOriginCheck: boolean | string[];
         skipCSRFCheck: boolean;
         runInBackground: (promise: Promise<unknown>) => void;
-        runInBackgroundOrAwait: (promise: Promise<unknown> | void) => better_auth0.Awaitable<unknown>;
+        runInBackgroundOrAwait: (promise: Promise<unknown> | void) => import("better-auth").Awaitable<unknown>;
       }> | {
         electron_authorization_code: string;
       } | undefined>;
     })[];
   };
   endpoints: {
-    electronToken: better_call0.StrictEndpoint<"/electron/token", {
+    electronToken: import("better-call").StrictEndpoint<"/electron/token", {
       method: "POST";
       body: z.ZodObject<{
         token: z.ZodString;
@@ -197,9 +193,9 @@ declare const electron: (options?: ElectronOptions | undefined) => {
       };
     }, {
       token: string;
-      user: better_auth0.User & Record<string, any>;
+      user: import("better-auth").User & Record<string, any>;
     }>;
-    electronInitOAuthProxy: better_call0.StrictEndpoint<"/electron/init-oauth-proxy", {
+    electronInitOAuthProxy: import("better-call").StrictEndpoint<"/electron/init-oauth-proxy", {
       method: "GET";
       query: z.ZodObject<{
         provider: z.ZodString;
@@ -246,10 +242,10 @@ declare const electron: (options?: ElectronOptions | undefined) => {
     }, {
       url: string | undefined;
       redirect: boolean;
-      user?: better_auth0.User & Record<string, any>;
+      user?: import("better-auth").User & Record<string, any>;
       token?: string;
     } | undefined>;
-    electronTransferUser: better_call0.StrictEndpoint<"/electron/transfer-user", {
+    electronTransferUser: import("better-call").StrictEndpoint<"/electron/transfer-user", {
       method: "POST";
       query: z.ZodObject<{
         client_id: z.ZodString;
@@ -260,7 +256,7 @@ declare const electron: (options?: ElectronOptions | undefined) => {
       body: z.ZodObject<{
         callbackURL: z.ZodOptional<z.ZodString>;
       }, z.core.$strip>;
-      use: ((inputContext: better_call0.MiddlewareInputContext<better_call0.MiddlewareOptions>) => Promise<{
+      use: ((inputContext: import("better-call").MiddlewareInputContext<import("better-call").MiddlewareOptions>) => Promise<{
         session: {
           session: Record<string, any> & {
             id: string;
@@ -329,15 +325,15 @@ declare const electron: (options?: ElectronOptions | undefined) => {
     clientID: string;
   };
   $ERROR_CODES: {
-    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">;
+    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">;
   };
 };
 //#endregion
-export { ElectronOptions, ElectronSharedOptions, FetchUserImageResult, electron, fetchUserImage, normalizeUserOutput };
+export { type ElectronOptions, type ElectronSharedOptions, type FetchUserImageResult, electron, type fetchUserImage, type normalizeUserOutput };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { t as PACKAGE_VERSION } from "./version-CD3Z0v2C.mjs";
+import { t as PACKAGE_VERSION } from "./version-DsNmK8I4.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";
@@ -12,7 +12,7 @@ import { safeJSONParse as safeJSONParse$1 } from "@better-auth/core/utils/json";
 import { createHash } from "@better-auth/utils/hash";
 import { betterFetch } from "@better-fetch/fetch";
 import { createAuthEndpoint, sessionMiddleware } from "better-auth/api";
-import { setSessionCookie } from "better-auth/cookies";
+import { parseSetCookieHeader, setSessionCookie, toCookieOptions } from "better-auth/cookies";
 import { parseUserOutput } from "better-auth/db";
 //#region src/error-codes.ts
 const ELECTRON_ERROR_CODES = defineErrorCodes({
@@ -121,7 +121,7 @@ const electronInitOAuthProxy = (opts) => createAuthEndpoint("/electron/init-oaut
 	if (ctx.query.code_challenge_method && ctx.query.code_challenge_method.toLowerCase() !== "s256") throw APIError.from("BAD_REQUEST", ELECTRON_ERROR_CODES.INVALID_PKCE_METHOD);
 	const headers = new Headers(ctx.request?.headers);
 	headers.set("origin", new URL(ctx.context.baseURL).origin);
-	let setCookie = null;
+	let setCookies = [];
 	const searchParams = new URLSearchParams();
 	searchParams.set("client_id", opts.clientID || "electron");
 	searchParams.set("code_challenge", ctx.query.code_challenge);
@@ -131,13 +131,15 @@ const electronInitOAuthProxy = (opts) => createAuthEndpoint("/electron/init-oaut
 		baseURL: ctx.context.baseURL,
 		method: "POST",
 		body: { provider: ctx.query.provider },
-		onResponse: (ctx) => {
-			setCookie = ctx.response.headers.get("set-cookie") ?? null;
+		onResponse: (innerCtx) => {
+			setCookies = innerCtx.response.headers.getSetCookie();
 		},
 		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);
+	for (const cookieStr of setCookies) parseSetCookieHeader(cookieStr).forEach((attrs, name) => {
+		ctx.setCookie(name, attrs.value, toCookieOptions(attrs));
+	});
 	if (res.data.url && res.data.redirect) {
 		ctx.setHeader("Location", res.data.url);
 		ctx.setStatus(302);