nuxt-convex-module 0.10.0 → 0.11.0

package/dist/module.d.mts

@@ -112,12 +112,12 @@ interface ModuleOptions {
     /**
      * Run Convex beside Nuxt with one command. On the first `nuxt dev` (or
      * `nuxt prepare`) in an app whose `dev` script is still the plain
-     * `nuxt dev`, the module rewrites it to `convex dev --start 'nuxt dev'`:
-     * the Convex CLI starts the dev deployment, starts Nuxt next to it, and
-     * hands it `CONVEX_URL` / `CONVEX_SITE_URL` in the environment — no `.env`
-     * needed for local development. A `dev` script you have already changed,
-     * or one that runs `convex dev` somewhere, is left alone. Set `false` to
-     * never touch `package.json`.
+     * `nuxt dev`, the module rewrites it to `convex dev --start "nuxt dev"`:
+     * the Convex CLI starts the dev deployment, writes its URL to `.env.local`
+     * and starts Nuxt next to it, and the module reads that file in
+     * development — no `.env` needed for local development. A `dev` script you
+     * have already changed, or one that runs `convex dev` somewhere, is left
+     * alone. Set `false` to never touch `package.json`.
      */
     devScript?: boolean;
 }

package/dist/module.json

@@ -5,7 +5,7 @@
   "compatibility": {
     "nuxt": ">=4.1.0"
   },
-  "version": "0.10.0",
+  "version": "0.11.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,7 +1,9 @@
 import { useLogger, updateTemplates, defineNuxtModule, createResolver, addPlugin, hasNuxtModule, addServerPlugin, addPluginTemplate, addTypeTemplate, addImports, addServerImports, addComponent, addServerHandler, extendRouteRules, addRouteMiddleware } from '@nuxt/kit';
-import { join, isAbsolute } from 'node:path';
+import { dirname, join, isAbsolute, basename } from 'node:path';
+import { detectAgent } from 'std-env';
 import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { parseEnv } from 'node:util';
 
 function resolveIntegrationState(explicit, installed, declared = installed) {
   if (explicit === false) return { enabled: false, missingPackage: false };
@@ -110,11 +112,16 @@ function formatStartupSummary(url, functionsDir, integrations) {
   return `Convex ${url || "(no URL)"} \xB7 functions: ${functionsDir}/ \xB7 integrations: ${enabled.join(", ") || "none"}`;
 }
 function isPackageInstalled(id, rootDir) {
-  for (const base of [join(rootDir, "package.json"), import.meta.url]) {
-    const lookupPaths = createRequire(base).resolve.paths(id) ?? [];
-    if (lookupPaths.some((dir) => existsSync(join(dir, id, "package.json")))) return true;
+  return [rootDir, dirname(fileURLToPath(import.meta.url))].some(
+    (base) => nodeModulesPaths(base).some((dir) => existsSync(join(dir, id, "package.json")))
+  );
+}
+function nodeModulesPaths(dir) {
+  const paths = [];
+  for (let current = dir; ; current = dirname(current)) {
+    if (basename(current) !== "node_modules") paths.push(join(current, "node_modules"));
+    if (dirname(current) === current) return paths;
   }
-  return false;
 }
 function resolveDeploymentUrls(options, env) {
   return {
@@ -122,6 +129,16 @@ function resolveDeploymentUrls(options, env) {
     siteUrl: stripTrailingSlashes(options.siteUrl || env.NUXT_PUBLIC_CONVEX_SITE_URL || env.CONVEX_SITE_URL || "")
   };
 }
+function deploymentEnv(rootDir, env, dev) {
+  if (!dev) return env;
+  let local;
+  try {
+    local = parseEnv(readFileSync(join(rootDir, ".env.local"), "utf8"));
+  } catch {
+    return env;
+  }
+  return { ...local, ...env };
+}
 
 const logger$1 = useLogger("nuxt-convex-module");
 const DEFAULT_FUNCTIONS_DIR = "convex";
@@ -175,9 +192,9 @@ function watchConvexCodegen(nuxt) {
   });
 }
 
-const PLAIN_NUXT_DEV = /^(?:npx )?(?:nuxt|nuxi) dev(?: [^&|;]*)?$/;
+const PLAIN_NUXT_DEV = /^(?:npx )?(?:nuxt|nuxi) dev(?: [^&|;"']*)?$/;
 function combinedDevScript(nuxtCommand) {
-  return `convex dev --start '${nuxtCommand}'`;
+  return `convex dev --start "${nuxtCommand}"`;
 }
 function setupDevScript(rootDir) {
   const path = join(rootDir, "package.json");
@@ -349,6 +366,8 @@ const module$1 = defineNuxtModule({
   async setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
     nuxt.options.build.transpile.push(resolver.resolve("./runtime"));
+    nuxt.options.vite.resolve ??= {};
+    nuxt.options.vite.resolve.dedupe = [...nuxt.options.vite.resolve.dedupe ?? [], "convex"];
     const { url, siteUrl } = applyRuntimeConfig(nuxt, options);
     const diagnostics = validateModuleOptions({
       url,
@@ -389,10 +408,17 @@ const module$1 = defineNuxtModule({
       const result = setupDevScript(nuxt.options.rootDir);
       if (result.changed) {
         logger.info(`Set \`scripts.dev\` to \`${result.to}\` \u2014 one command now runs Convex beside Nuxt, no .env needed locally. Set \`convex.devScript: false\` to keep your own script.`);
+        hintAgent();
       }
     }
   }
 });
+let agentHinted = false;
+function hintAgent() {
+  if (agentHinted || !detectAgent().name) return;
+  agentHinted = true;
+  logger.info("An AI agent is running Nuxt. `CONVEX_AGENT_MODE=anonymous npx convex dev --once` sets up a local Convex deployment with no prompts and no account, writes .env.local and the codegen, then exits. For the setup steps and this module's API: `npx skills add https://nuxt-convex-module.dev --skill nuxt-convex-module -y`.");
+}
 function isDevtoolsUiEnabled(nuxt) {
   const devtools = nuxt.options.devtools;
   return typeof devtools === "boolean" ? devtools : devtools?.enabled !== false;
@@ -448,12 +474,13 @@ function registerSecurity(resolver) {
   addServerPlugin(resolver.resolve("./runtime/nuxt/security"));
 }
 function applyRuntimeConfig(nuxt, options) {
-  const resolved = resolveDeploymentUrls(options, process.env);
+  const resolved = resolveDeploymentUrls(options, deploymentEnv(nuxt.options.rootDir, process.env, nuxt.options.dev));
   const url = nuxt.options._prepare ? "" : resolved.url;
   if (!url && !nuxt.options._prepare) {
     logger.warn(
-      "No Convex deployment URL configured. Set NUXT_PUBLIC_CONVEX_URL or `convex.url` in nuxt.config. Note: `npx convex dev` writes CONVEX_URL to .env.local, which Nuxt does not read without `nuxt dev --dotenv .env.local`."
+      "No Convex deployment URL configured. Set NUXT_PUBLIC_CONVEX_URL or `convex.url` in nuxt.config, or run `npx convex dev`: it writes CONVEX_URL to .env.local, which the module reads in development."
     );
+    hintAgent();
   }
   const siteUrl = resolved.siteUrl;
   const crossDomainCallbackRoute = typeof options.betterAuth === "object" && options.betterAuth.crossDomainCallbackRoute || "";
@@ -497,6 +524,7 @@ function registerConvexApiPlugin(resolver, nuxt) {
         if (nuxt.options.dev && !nuxt.options._prepare && !notifiedMissing) {
           notifiedMissing = true;
           logger.info(`Convex codegen not found in \`${functionsDir}/_generated\` \u2014 run \`npx convex dev\`. Convex features no-op until it exists.`);
+          hintAgent();
         }
         return "import { defineNuxtPlugin } from '#app'\nexport default defineNuxtPlugin(() => {})\n";
       }

package/dist/runtime/auth0/vue/index.js

@@ -6,7 +6,7 @@ export function provideConvexAuthFromAuth0(options = {}) {
   const client = options.client ?? useConvexOrThrow("provideConvexAuthFromAuth0");
   return provideConvexAuth({ client, useAuth: useAuthFromAuth0 });
 }
-export const ConvexProviderWithAuth0 = defineComponent({
+export const ConvexProviderWithAuth0 = /* @__PURE__ */ defineComponent({
   name: "ConvexProviderWithAuth0",
   props: {
     client: { type: Object, default: void 0 }

package/dist/runtime/better-auth/nuxt/middleware.js

@@ -1,18 +1,7 @@
-import { defineNuxtRouteMiddleware, navigateTo, useNuxtApp, useRequestEvent, useRuntimeConfig } from "#app";
+import { defineNuxtRouteMiddleware, navigateTo, useRuntimeConfig } from "#app";
 import { watch } from "vue";
 import { useBetterAuth } from "../vue/use-better-auth.js";
-import { convexAuth } from "./server.js";
-function loginTarget(to, loginPath) {
-  return { path: loginPath, query: { redirect: to.fullPath } };
-}
-export async function serverGuard(to, loginPath) {
-  const nuxtApp = useNuxtApp();
-  const event = useRequestEvent();
-  const authed = event ? await convexAuth(event).isAuthenticated() : false;
-  if (!authed && to.path !== loginPath) {
-    return nuxtApp.runWithContext(() => navigateTo(loginTarget(to, loginPath)));
-  }
-}
+import { loginTarget, serverGuard } from "./server-guard.js";
 function waitForSession(isPending) {
   return new Promise((resolve) => {
     const stop = watch(

package/dist/runtime/better-auth/nuxt/server-guard.d.ts

@@ -0,0 +1,12 @@
+interface GuardedRoute {
+    path: string;
+    fullPath: string;
+}
+/** Where a visitor who isn't signed in goes: the login page, with the page they asked for in `?redirect=`. */
+export declare function loginTarget(to: GuardedRoute, loginPath: string): {
+    path: string;
+    query: {
+        redirect: string;
+    };
+};
+export {};

package/dist/runtime/better-auth/nuxt/server-guard.js

@@ -0,0 +1,13 @@
+import { navigateTo, useNuxtApp, useRequestEvent } from "#app";
+import { convexAuth } from "./server.js";
+export function loginTarget(to, loginPath) {
+  return { path: loginPath, query: { redirect: to.fullPath } };
+}
+export async function serverGuard(to, loginPath) {
+  const nuxtApp = useNuxtApp();
+  const event = useRequestEvent();
+  const authed = event ? await convexAuth(event).isAuthenticated() : false;
+  if (!authed && to.path !== loginPath) {
+    return nuxtApp.runWithContext(() => navigateTo(loginTarget(to, loginPath)));
+  }
+}

package/dist/runtime/better-auth/vue/auth-boundary.js

@@ -2,7 +2,7 @@ import { defineComponent, h, onErrorCaptured, ref, watch } from "vue";
 import { useConvexAuth } from "../../vue/auth/index.js";
 import { Authenticated } from "../../vue/auth/helpers.js";
 import { useQuery } from "../../vue/composables/use-query.js";
-const UserSubscription = defineComponent({
+const UserSubscription = /* @__PURE__ */ defineComponent({
   name: "UserSubscription",
   props: {
     getAuthUserFn: { type: Object, required: true }
@@ -15,7 +15,7 @@ const UserSubscription = defineComponent({
     };
   }
 });
-export const AuthBoundary = defineComponent({
+export const AuthBoundary = /* @__PURE__ */ defineComponent({
   name: "AuthBoundary",
   props: {
     /**

package/dist/runtime/better-auth/vue/client.d.ts

@@ -1,358 +1,6 @@
-export declare const authClient: import("better-auth/vue").VueAuthClient<{
-    plugins: {
-        id: "convex";
-        version: string;
-        $InferServerPlugin: ReturnType<(opts: {
-            authConfig: import("convex/server").AuthConfig;
-            jwt?: {
-                expirationSeconds?: number;
-                definePayload?: (session: {
-                    user: import("better-auth").User & Record<string, any>;
-                    session: import("better-auth").Session & Record<string, any>;
-                }) => Promise<Record<string, any>> | Record<string, any> | undefined;
-            };
-            jwtExpirationSeconds?: number;
-            jwks?: string;
-            jwksRotateOnTokenGenerationError?: boolean;
-            options?: import("better-auth").BetterAuthOptions;
-        }) => {
-            id: "convex";
-            version: string;
-            init: (ctx: import("better-auth").AuthContext) => void;
-            hooks: {
-                before: ({
-                    matcher(context: import("better-auth").HookEndpointContext): boolean;
-                    handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
-                        context: {
-                            headers: Headers;
-                        };
-                    } | undefined>;
-                } | {
-                    matcher: (ctx: import("better-auth").HookEndpointContext) => boolean;
-                    handler: (inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
-                        context: import("better-auth").MiddlewareContext<import("better-auth").MiddlewareOptions, {
-                            returned?: unknown | undefined;
-                            responseHeaders?: Headers | undefined;
-                        } & 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?: {
-                                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: import("better-auth").OAuthProvider[];
-                            authCookies: import("better-auth").BetterAuthCookies;
-                            logger: ReturnType<(options?: import("better-auth").Logger | undefined) => import("better-auth").InternalLogger>;
-                            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-auth").CookieOptions> | undefined) => import("better-auth").BetterAuthCookie;
-                            secret: string;
-                            secretConfig: string | import("better-auth").SecretConfig;
-                            sessionConfig: {
-                                updateAge: number;
-                                expiresIn: number;
-                                freshAge: number;
-                                cookieRefreshCache: false | {
-                                    enabled: true;
-                                    updateAge: number;
-                                };
-                            };
-                            generateId: (options: {
-                                model: import("better-auth").ModelNames;
-                                size?: number | undefined;
-                            }) => string | false;
-                            secondaryStorage: import("better-auth").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: import("better-auth").GenericEndpointContext<import("better-auth").BetterAuthOptions>) => Promise<boolean>;
-                            };
-                            tables: import("better-auth").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) => import("better-auth").Awaitable<unknown>;
-                        }>;
-                    }>;
-                })[];
-                after: {
-                    matcher: (context: import("better-auth").HookEndpointContext) => boolean;
-                    handler: import("better-auth/api").AuthMiddleware;
-                }[];
-            };
-            endpoints: {
-                getOpenIdConfig: import("better-auth").StrictEndpoint<"/convex/.well-known/openid-configuration", {
-                    method: "GET";
-                    metadata: {
-                        isAction: false;
-                    };
-                }, import("better-auth/plugins/oidc-provider").OIDCMetadata>;
-                getJwks: import("better-auth").StrictEndpoint<"/convex/jwks", {
-                    method: "GET";
-                    metadata: {
-                        openapi: {
-                            description: string;
-                            responses: {
-                                "200": {
-                                    description: string;
-                                    content: {
-                                        "application/json": {
-                                            schema: {
-                                                type: "object";
-                                                properties: {
-                                                    keys: {
-                                                        type: string;
-                                                        description: string;
-                                                        items: {
-                                                            type: string;
-                                                            properties: {
-                                                                kid: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                };
-                                                                kty: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                };
-                                                                alg: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                };
-                                                                use: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                    enum: string[];
-                                                                    nullable: boolean;
-                                                                };
-                                                                n: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                    nullable: boolean;
-                                                                };
-                                                                e: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                    nullable: boolean;
-                                                                };
-                                                                crv: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                    nullable: boolean;
-                                                                };
-                                                                x: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                    nullable: boolean;
-                                                                };
-                                                                y: {
-                                                                    type: string;
-                                                                    description: string;
-                                                                    nullable: boolean;
-                                                                };
-                                                            };
-                                                            required: string[];
-                                                        };
-                                                    };
-                                                };
-                                                required: string[];
-                                            };
-                                        };
-                                    };
-                                };
-                            };
-                        };
-                    };
-                }, import("better-auth").JSONWebKeySet>;
-                getLatestJwks: import("better-auth").StrictEndpoint<"/convex/latest-jwks", {
-                    isAction: boolean;
-                    method: "POST";
-                    metadata: {
-                        SERVER_ONLY: true;
-                        openapi: {
-                            description: string;
-                        };
-                    };
-                }, any[]>;
-                rotateKeys: import("better-auth").StrictEndpoint<"/convex/rotate-keys", {
-                    isAction: boolean;
-                    method: "POST";
-                    metadata: {
-                        SERVER_ONLY: true;
-                        openapi: {
-                            description: string;
-                        };
-                    };
-                }, any[]>;
-                getToken: import("better-auth").StrictEndpoint<"/convex/token", {
-                    method: "GET";
-                    requireHeaders: true;
-                    use: ((inputContext: import("better-auth").MiddlewareInputContext<import("better-auth").MiddlewareOptions>) => Promise<{
-                        session: {
-                            session: Record<string, any> & {
-                                id: string;
-                                createdAt: Date;
-                                updatedAt: Date;
-                                userId: string;
-                                expiresAt: Date;
-                                token: string;
-                                ipAddress?: string | null | undefined;
-                                userAgent?: string | null | undefined;
-                            };
-                            user: Record<string, any> & {
-                                id: string;
-                                createdAt: Date;
-                                updatedAt: Date;
-                                email: string;
-                                emailVerified: boolean;
-                                name: string;
-                                image?: string | null | undefined;
-                            };
-                        };
-                    }>)[];
-                    metadata: {
-                        openapi: {
-                            description: string;
-                            responses: {
-                                200: {
-                                    description: string;
-                                    content: {
-                                        "application/json": {
-                                            schema: {
-                                                type: "object";
-                                                properties: {
-                                                    token: {
-                                                        type: string;
-                                                    };
-                                                };
-                                            };
-                                        };
-                                    };
-                                };
-                            };
-                        };
-                    };
-                }, {
-                    token: string;
-                }>;
-            };
-            schema: {
-                jwks: {
-                    fields: {
-                        publicKey: {
-                            type: "string";
-                            required: true;
-                        };
-                        privateKey: {
-                            type: "string";
-                            required: true;
-                        };
-                        createdAt: {
-                            type: "date";
-                            required: true;
-                        };
-                        expiresAt: {
-                            type: "date";
-                            required: false;
-                        };
-                    };
-                };
-                user: {
-                    readonly fields: {
-                        readonly userId: {
-                            readonly type: "string";
-                            readonly required: false;
-                            readonly input: false;
-                        };
-                    };
-                };
-            };
-        }>;
-    }[];
-}>;
+import { convexClient } from '@convex-dev/better-auth/client/plugins';
+import { createAuthClient } from 'better-auth/vue';
+export declare const authClient: ReturnType<typeof createAuthClient<{
+    plugins: ReturnType<typeof convexClient>[];
+}>>;
 export type AuthClient = typeof authClient;

package/dist/runtime/better-auth/vue/use-better-auth.d.ts

@@ -1,70 +1,10 @@
 import type { AuthTokenFetcher } from 'convex/browser';
 import { type ComputedRef } from 'vue';
 import { type AuthClient } from '#convex/auth-client';
-declare const useClientSession: () => Readonly<import("vue").Ref<{
-    readonly data: {
-        readonly user: {
-            readonly id: string;
-            readonly createdAt: Date;
-            readonly updatedAt: Date;
-            readonly email: string;
-            readonly emailVerified: boolean;
-            readonly name: string;
-            readonly image?: string | null | undefined;
-            readonly userId?: string | null | undefined;
-        };
-        readonly session: {
-            readonly id: string;
-            readonly createdAt: Date;
-            readonly updatedAt: Date;
-            readonly userId: string;
-            readonly expiresAt: Date;
-            readonly token: string;
-            readonly ipAddress?: string | null | undefined;
-            readonly userAgent?: string | null | undefined;
-        };
-    } | null;
-    readonly isPending: boolean;
-    readonly isRefetching: boolean;
-    readonly error: import("better-auth/client").BetterFetchError | null;
-    readonly refetch: (queryParams
-    /** The Better Auth client from `#convex/auth-client` — sign-in, sign-out and every plugin flow live here. */
-    ?: {
-        query?: import("better-auth").SessionQueryParams;
-    } | undefined) => Promise<void>;
-}, {
-    readonly data: {
-        readonly user: {
-            readonly id: string;
-            readonly createdAt: Date;
-            readonly updatedAt: Date;
-            readonly email: string;
-            readonly emailVerified: boolean;
-            readonly name: string;
-            readonly image?: string | null | undefined;
-            readonly userId?: string | null | undefined;
-        };
-        readonly session: {
-            readonly id: string;
-            readonly createdAt: Date;
-            readonly updatedAt: Date;
-            readonly userId: string;
-            readonly expiresAt: Date;
-            readonly token: string;
-            readonly ipAddress?: string | null | undefined;
-            readonly userAgent?: string | null | undefined;
-        };
-    } | null;
-    readonly isPending: boolean;
-    readonly isRefetching: boolean;
-    readonly error: import("better-auth/client").BetterFetchError | null;
-    readonly refetch: (queryParams
-    /** The Better Auth client from `#convex/auth-client` — sign-in, sign-out and every plugin flow live here. */
-    ?: {
-        query?: import("better-auth").SessionQueryParams;
-    } | undefined) => Promise<void>;
-}>>;
-export type BetterAuthSession = ReturnType<typeof useClientSession>;
+export type BetterAuthSession = AuthClient['useSession'] extends {
+    (): infer R;
+    (useFetch: any): any;
+} ? R : never;
 /** The signed-in user (loose — exact fields depend on your auth schema). */
 export type BetterAuthUser = {
     id: string;
@@ -109,4 +49,3 @@ export interface UseBetterAuthReturn {
  * @public
  */
 export declare function useBetterAuth(initialToken?: string | null): UseBetterAuthReturn;
-export {};