use-convex 1.2.0 → 2.0.0

package/dist/runtime/utils/authClientOptions.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Runtime knobs for the Convex Auth client that can't live in serializable
+ * module options: a custom TokenStorage, extra ambient sign-ins, or a custom
+ * `replaceUrl`. Call {@link configureConvexAuth} from a client plugin with
+ * `enforce: 'pre'` so the options land before the auth plugin creates the
+ * client.
+ */
+/**
+ * Token storage (`@convex-dev/auth/browser` `TokenStorage`). Methods may be
+ * sync or async, e.g. Capacitor Preferences or an encrypted store.
+ */
+export type ConvexAuthTokenStorage = {
+    getItem: (key: string) => string | null | undefined | Promise<string | null | undefined>;
+    setItem: (key: string, value: string) => void | Promise<void>;
+    removeItem: (key: string) => void | Promise<void>;
+};
+export type { ConvexAuthStorageMode } from './authStorage.js';
+/**
+ * An ambient sign-in registration (`AmbientSignInClient` in
+ * `@convex-dev/auth`): a method that finishes on its own at startup, like
+ * an OAuth callback. Typed loosely here so this file needs no Convex Auth
+ * import; the auth plugin passes it straight to `AuthClient`.
+ */
+export type ConvexAmbientSignIn = {
+    id: string;
+    setup: (ctx: never) => void | {
+        onInit?: () => void;
+    };
+};
+export type ConvexAuthClientOptions = {
+    /**
+     * Custom token storage. Overrides `convex.auth.storage`.
+     */
+    storage?: ConvexAuthTokenStorage;
+    /**
+     * Replaces the default ambient sign-ins (`[oauth()]`). Pass `[]` to
+     * disable OAuth callback handling, or include `convexOAuth()` alongside
+     * your own.
+     */
+    ambientSignIns?: ConvexAmbientSignIn[];
+    /**
+     * Replace the page URL after an OAuth callback strips its params.
+     * Defaults to `history.replaceState`, then syncs `vue-router`.
+     */
+    replaceUrl?: (url: string) => void;
+};
+/**
+ * Set runtime Convex Auth knobs. Merge is shallow — later calls override
+ * earlier keys.
+ */
+export declare function configureConvexAuth(options: ConvexAuthClientOptions): void;
+export declare function getConvexAuthClientOptions(): ConvexAuthClientOptions;
+/** @internal */
+export declare function resetConvexAuthClientOptionsForTests(): void;

package/dist/runtime/utils/authClientOptions.js

@@ -0,0 +1,10 @@
+let runtimeOverrides = {};
+export function configureConvexAuth(options) {
+  runtimeOverrides = { ...runtimeOverrides, ...options };
+}
+export function getConvexAuthClientOptions() {
+  return { ...runtimeOverrides };
+}
+export function resetConvexAuthClientOptionsForTests() {
+  runtimeOverrides = {};
+}

package/dist/runtime/utils/authCookie.d.ts

@@ -1,19 +1,13 @@
-import { type ComputedRef } from 'vue';
+import { type ComputedRef, type Ref } from 'vue';
 /**
- * Shared JWT cookie for SSR snapshots. Same name + options as persistTokens
- * so plugin reads and sign-in/out writes share one Nuxt cookie ref.
- *
- * When `auth.httpOnly` is set, this cookie is HttpOnly (server-readable only).
+ * Convex Auth access token shared between server and client via the Nuxt
+ * payload. The server fills it from the (refreshed) SSR session; the client
+ * auth plugin keeps it in sync with the live `AuthClient` token.
  */
+export declare function useConvexAuthTokenState(): Ref<string | null>;
+/** BYO providers: readable JWT cookie written by the app after sign-in. */
 export declare function useAuthJwtCookie(): import("nuxt/app").CookieRef<string | null> | undefined;
-/**
- * Readable presence marker used when JWT is HttpOnly so the client can still
- * compute `hasSsrSession` / `showAuthedUi` without reading the token.
- */
-export declare function useAuthPresentCookie(): import("nuxt/app").CookieRef<string | null> | undefined;
-/** Reactive JWT for HttpClient + SSR. Empty on the client when HttpOnly. */
+/** Reactive JWT for HttpClient + SSR. */
 export declare function useSsrTokenRef(): ComputedRef<string | undefined>;
-/**
- * Session hint for UI gating: JWT readable, or HttpOnly presence cookie.
- */
+/** Session hint for UI gating: a JWT is known for this request / client. */
 export declare function useHasSsrSessionRef(): ComputedRef<boolean>;

package/dist/runtime/utils/authCookie.js

@@ -1,46 +1,42 @@
 import { computed } from "vue";
-import { useCookie, useRuntimeConfig } from "nuxt/app";
+import { useCookie, useRuntimeConfig, useState } from "nuxt/app";
 import {
-  AUTH_JWT_COOKIE_MAX_AGE,
+  SSR_TOKEN_STATE_KEY,
   cookieValueToSsrToken,
-  isHttpOnlyAuth,
-  resolveAuthCookieName,
-  resolveAuthPresentCookieName
+  isConvexAuth,
+  resolveAuthCookieName
 } from "./authStorage.js";
-function cookieOptions(httpOnly) {
-  return {
-    sameSite: "lax",
-    secure: process.env.NODE_ENV === "production",
-    maxAge: AUTH_JWT_COOKIE_MAX_AGE,
-    path: "/",
-    httpOnly
-  };
+function readAuthConfig() {
+  const config = useRuntimeConfig();
+  return config.public.convex?.auth;
+}
+export function useConvexAuthTokenState() {
+  return useState(SSR_TOKEN_STATE_KEY, () => null);
 }
 export function useAuthJwtCookie() {
-  const config = useRuntimeConfig();
-  const convexConfig = config.public.convex;
-  const name = resolveAuthCookieName(convexConfig?.auth);
-  if (!name) {
+  const auth = readAuthConfig();
+  if (isConvexAuth(auth)) {
     return void 0;
   }
-  const httpOnly = isHttpOnlyAuth(convexConfig?.auth);
-  return useCookie(name, cookieOptions(httpOnly));
-}
-export function useAuthPresentCookie() {
-  const config = useRuntimeConfig();
-  const convexConfig = config.public.convex;
-  const name = resolveAuthPresentCookieName(convexConfig?.auth);
+  const name = resolveAuthCookieName(auth);
   if (!name) {
     return void 0;
   }
-  return useCookie(name, cookieOptions(false));
+  return useCookie(name, {
+    sameSite: "lax",
+    secure: process.env.NODE_ENV === "production",
+    path: "/"
+  });
 }
 export function useSsrTokenRef() {
+  if (isConvexAuth(readAuthConfig())) {
+    const state = useConvexAuthTokenState();
+    return computed(() => state.value || void 0);
+  }
   const cookie = useAuthJwtCookie();
   return computed(() => cookieValueToSsrToken(cookie?.value));
 }
 export function useHasSsrSessionRef() {
   const token = useSsrTokenRef();
-  const present = useAuthPresentCookie();
-  return computed(() => !!token.value || present?.value === "1");
+  return computed(() => !!token.value);
 }

package/dist/runtime/utils/authStorage.d.ts

@@ -1,55 +1,93 @@
 /**
- * Convex Auth client storage helpers (mirrors @convex-dev/auth/react).
+ * Shared auth configuration helpers.
+ *
+ * Kept free of `@convex-dev/auth` imports: apps that bring their own provider
+ * (Clerk, Auth0, custom JWT) load this file without installing Convex Auth.
  */
-export declare const JWT_STORAGE_KEY = "__convexAuthJWT";
-export declare const REFRESH_TOKEN_STORAGE_KEY = "__convexAuthRefreshToken";
-export declare const VERIFIER_STORAGE_KEY = "__convexAuthOAuthVerifier";
-export declare const AUTH_JWT_COOKIE_MAX_AGE: number;
-export declare const DEFAULT_CONVEX_AUTH_COOKIE = "convex_jwt";
-/** Readable marker so the client knows an HttpOnly session exists. */
-export declare const DEFAULT_AUTH_PRESENT_COOKIE = "convex_auth_present";
-/** HttpOnly JWT cookie (Next.js Convex Auth naming). */
-export declare const HTTPONLY_JWT_COOKIE = "__convexAuthJWT";
-/** HttpOnly refresh cookie. */
-export declare const HTTPONLY_REFRESH_COOKIE = "__convexAuthRefreshToken";
+/** Session model for first-party Convex Auth v2. */
+export type ConvexAuthMode = 'ssr' | 'spa';
+/** Client token storage for Convex Auth. */
+export type ConvexAuthStorageMode = 'localStorage' | 'inMemory';
+/**
+ * Names of the session functions `setupConvexAuth` returns, as exported from
+ * the app's Convex functions (e.g. `convex/auth.ts` → `'auth:refreshSession'`).
+ */
+export type ConvexAuthApiNames = {
+    refreshSession?: string;
+    signOut?: string;
+    isAuthenticated?: string;
+};
 export type ConvexAuthConfig = {
-    provider?: string;
-    cookie?: string;
+    provider?: 'convex-auth';
     /**
-     * Store JWT + refresh in HttpOnly cookies via Nitro (Next.js parity).
-     * When true, JS cannot read tokens from `document.cookie`; `fetchToken`
-     * uses same-origin POST `/api/convex/auth/session` with `{ getToken: true }`.
-     * Prefer `true` in production. Does not make sessions XSS-proof.
+     * BYO providers: cookie whose value is a JWT for SSR queries and Nitro
+     * `fetch*` helpers. Ignored for `provider: 'convex-auth'`, which manages
+     * its own cookies.
      */
-    httpOnly?: boolean;
-    /** Readable presence cookie when `httpOnly` is set (UI only). */
-    presentCookie?: string;
+    cookie?: string;
+    /** @see ModuleAuthOptions.mode */
+    mode?: ConvexAuthMode;
+    /** @see ModuleAuthOptions.api */
+    api?: ConvexAuthApiNames;
+    /** @see ModuleAuthOptions.routePrefix */
+    routePrefix?: string;
+    /** @see ModuleAuthOptions.storageNamespace */
+    storageNamespace?: string;
+    /** @see ModuleAuthOptions.storage */
+    storage?: ConvexAuthStorageMode;
+    /** @see ModuleAuthOptions.verbose */
+    verbose?: boolean;
+};
+/** Server-only Convex Auth options (`runtimeConfig.convexAuth`). */
+export interface ConvexAuthServerRuntimeConfig {
+    /** Sign-in function names the auth proxy forwards, e.g. `'auth:signInWithUsernamePassword'`. */
+    signIn?: string[];
+    /** Origins trusted besides the request's own Host. */
+    allowedOrigins?: string[];
+    /** Cookie attributes. `secure` defaults to true except on localhost. */
+    cookie?: {
+        secure?: boolean;
+        domain?: string;
+        path?: string;
+    };
+}
+/** The Convex Auth v2 access-token cookie (fixed by `@convex-dev/auth/ssr`). */
+export declare const CONVEX_AUTH_JWT_COOKIE = "__convexAuthJWT";
+/** The Convex Auth v2 refresh-token cookie (fixed by `@convex-dev/auth/ssr`). */
+export declare const CONVEX_AUTH_REFRESH_COOKIE = "__convexAuthRefreshToken";
+export declare const DEFAULT_AUTH_ROUTE_PREFIX = "/api/convex/auth";
+export declare const DEFAULT_CONVEX_AUTH_API: Required<ConvexAuthApiNames>;
+/** `useState` key carrying the SSR access token to the client payload. */
+export declare const SSR_TOKEN_STATE_KEY = "convex:auth-token";
+export declare function isConvexAuth(auth?: ConvexAuthConfig): boolean;
+/** SSR mode is the default for Convex Auth: Nuxt renders on the server. */
+export declare function resolveAuthMode(auth?: ConvexAuthConfig): ConvexAuthMode;
+export declare function isSsrConvexAuth(auth?: ConvexAuthConfig): boolean;
+export declare function resolveAuthApiNames(auth?: ConvexAuthConfig): Required<ConvexAuthApiNames>;
+export declare function resolveAuthRoutes(auth?: ConvexAuthConfig): {
+    signIn: string;
+    refresh: string;
+    signOut: string;
 };
-export declare function storageNamespace(url: string): string;
-export declare function storageKey(base: string, url: string): string;
-/**
- * Flatten FormData (or pass through a plain record) the same way the React
- * Convex Auth client does before calling `auth:signIn`.
- */
-export declare function flattenSignInParams(params?: FormData | Record<string, string>): Record<string, string>;
 /**
- * Resolve the auth cookie name for runtime config / SSR JWT reads.
- * When `provider === 'convex-auth'` and cookie is omitted, default to `convex_jwt`
- * (or the HttpOnly JWT name when `httpOnly` is enabled).
+ * Cookie holding the JWT for SSR reads: the Convex Auth access-token cookie
+ * in SSR mode, the configured cookie for BYO providers, otherwise none.
+ * Convex Auth SPA mode keeps tokens in browser storage, so it has no cookie.
  */
 export declare function resolveAuthCookieName(auth?: ConvexAuthConfig): string | undefined;
-export declare function resolveAuthPresentCookieName(auth?: ConvexAuthConfig): string | undefined;
-export declare function resolveAuthRefreshCookieName(auth?: ConvexAuthConfig): string | undefined;
-export declare function isHttpOnlyAuth(auth?: ConvexAuthConfig): boolean;
 /** Empty / missing cookies are not a session. */
 export declare function cookieValueToSsrToken(value: string | null | undefined): string | undefined;
-export declare function readLocal(key: string): string | null;
-export declare function writeLocal(key: string, value: string | null): void;
 /**
- * Whether the current URL's `?code=` should be treated as an OAuth callback.
- * Only true when we previously stored a verifier (we started the flow).
+ * Whether a JWT's `exp` claim is within `skewSeconds` of now (or unreadable).
+ * Signature is not checked — this only decides whether to refresh.
+ */
+export declare function isJwtExpiring(token: string, skewSeconds?: number, nowMs?: number): boolean;
+/**
+ * A stable identity for the session a JWT belongs to: `iss` + `sub`.
+ *
+ * Convex Auth rotates the access token every minute but keeps the session
+ * id in `sub`, so this changes on sign-in / sign-out / account switch, not
+ * on rotation. Tokens without readable claims fall back to the token itself
+ * (any change is treated as a new session). Empty for no token.
  */
-export declare function shouldConsumeOAuthCode(options: {
-    code: string | null;
-    verifier: string | null;
-}): boolean;
+export declare function sessionKeyFromToken(token: string | null | undefined): string;

package/dist/runtime/utils/authStorage.js

@@ -1,85 +1,75 @@
-export const JWT_STORAGE_KEY = "__convexAuthJWT";
-export const REFRESH_TOKEN_STORAGE_KEY = "__convexAuthRefreshToken";
-export const VERIFIER_STORAGE_KEY = "__convexAuthOAuthVerifier";
-export const AUTH_JWT_COOKIE_MAX_AGE = 60 * 60 * 24 * 30;
-export const DEFAULT_CONVEX_AUTH_COOKIE = "convex_jwt";
-export const DEFAULT_AUTH_PRESENT_COOKIE = "convex_auth_present";
-export const HTTPONLY_JWT_COOKIE = "__convexAuthJWT";
-export const HTTPONLY_REFRESH_COOKIE = "__convexAuthRefreshToken";
-export function storageNamespace(url) {
-  return url.replace(/[^a-z0-9]/gi, "");
+export const CONVEX_AUTH_JWT_COOKIE = "__convexAuthJWT";
+export const CONVEX_AUTH_REFRESH_COOKIE = "__convexAuthRefreshToken";
+export const DEFAULT_AUTH_ROUTE_PREFIX = "/api/convex/auth";
+export const DEFAULT_CONVEX_AUTH_API = {
+  refreshSession: "auth:refreshSession",
+  signOut: "auth:signOut",
+  isAuthenticated: "auth:isAuthenticated"
+};
+export const SSR_TOKEN_STATE_KEY = "convex:auth-token";
+export function isConvexAuth(auth) {
+  return auth?.provider === "convex-auth";
 }
-export function storageKey(base, url) {
-  return `${base}_${storageNamespace(url)}`;
+export function resolveAuthMode(auth) {
+  return auth?.mode ?? "ssr";
 }
-export function flattenSignInParams(params) {
-  if (params === void 0) {
-    return {};
-  }
-  if (typeof FormData !== "undefined" && params instanceof FormData) {
-    const out = {};
-    params.forEach((value, key) => {
-      if (typeof value === "string") {
-        out[key] = value;
-      }
-    });
-    return out;
-  }
-  return { ...params };
+export function isSsrConvexAuth(auth) {
+  return isConvexAuth(auth) && resolveAuthMode(auth) === "ssr";
 }
-export function resolveAuthCookieName(auth) {
-  if (auth?.httpOnly) {
-    return auth.cookie ?? HTTPONLY_JWT_COOKIE;
-  }
-  if (auth?.cookie) {
-    return auth.cookie;
-  }
-  if (auth?.provider === "convex-auth") {
-    return DEFAULT_CONVEX_AUTH_COOKIE;
-  }
-  return void 0;
+export function resolveAuthApiNames(auth) {
+  return { ...DEFAULT_CONVEX_AUTH_API, ...auth?.api };
 }
-export function resolveAuthPresentCookieName(auth) {
-  if (!auth?.httpOnly) {
-    return void 0;
-  }
-  return auth.presentCookie ?? DEFAULT_AUTH_PRESENT_COOKIE;
+export function resolveAuthRoutes(auth) {
+  const prefix = (auth?.routePrefix ?? DEFAULT_AUTH_ROUTE_PREFIX).replace(/\/+$/, "");
+  return {
+    signIn: `${prefix}/signin`,
+    refresh: `${prefix}/refresh`,
+    signOut: `${prefix}/signout`
+  };
 }
-export function resolveAuthRefreshCookieName(auth) {
-  if (!auth?.httpOnly) {
-    return void 0;
+export function resolveAuthCookieName(auth) {
+  if (isConvexAuth(auth)) {
+    return isSsrConvexAuth(auth) ? CONVEX_AUTH_JWT_COOKIE : void 0;
   }
-  return HTTPONLY_REFRESH_COOKIE;
-}
-export function isHttpOnlyAuth(auth) {
-  return auth?.httpOnly === true;
+  return auth?.cookie || void 0;
 }
 export function cookieValueToSsrToken(value) {
   return value || void 0;
 }
-export function readLocal(key) {
-  if (typeof window === "undefined") {
-    return null;
+export function isJwtExpiring(token, skewSeconds = 10, nowMs = Date.now()) {
+  const payload = token.split(".")[1];
+  if (!payload) {
+    return true;
   }
   try {
-    return window.localStorage.getItem(key);
+    const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const json = typeof atob === "function" ? atob(padded) : globalThis.Buffer.from(padded, "base64").toString();
+    const exp = JSON.parse(json).exp;
+    if (typeof exp !== "number") {
+      return true;
+    }
+    return exp * 1e3 - skewSeconds * 1e3 <= nowMs;
   } catch {
-    return null;
+    return true;
   }
 }
-export function writeLocal(key, value) {
-  if (typeof window === "undefined") {
-    return;
+export function sessionKeyFromToken(token) {
+  if (!token) {
+    return "";
   }
-  try {
-    if (value === null) {
-      window.localStorage.removeItem(key);
-    } else {
-      window.localStorage.setItem(key, value);
+  const payload = token.split(".")[1];
+  if (payload) {
+    try {
+      const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+      const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+      const json = typeof atob === "function" ? atob(padded) : globalThis.Buffer.from(padded, "base64").toString();
+      const claims = JSON.parse(json);
+      if (typeof claims.sub === "string" && claims.sub) {
+        return `${typeof claims.iss === "string" ? claims.iss : ""}|${claims.sub}`;
+      }
+    } catch {
     }
-  } catch {
   }
-}
-export function shouldConsumeOAuthCode(options) {
-  return options.code !== null && options.verifier !== null;
+  return token;
 }

package/dist/runtime/utils/context.d.ts

@@ -1,5 +1,7 @@
 import type { AuthTokenFetcher, ConvexClient, ConvexHttpClient } from 'convex/browser';
-import type { ComputedRef, InjectionKey, Ref } from 'vue';
+import type { FunctionReference } from 'convex/server';
+import type { ComputedRef, InjectionKey, Ref, ShallowRef } from 'vue';
+import type { CreateHttpClientOptions } from './http.js';
 export interface ConvexAuthContext {
     /**
      * Whether useConvexAuth({ fetchToken }) has been called.
@@ -18,6 +20,36 @@ export interface ConvexAuthContext {
     isAuthenticated: Ref<boolean>;
     isRefreshing: Ref<boolean>;
 }
+/** Snapshot of the Convex Auth client (`AuthState` in `@convex-dev/auth`). */
+export interface ConvexAuthSnapshot {
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    token: string | null;
+}
+/**
+ * Runs a method's sign-in function. Direct to the deployment in SPA mode,
+ * through the Nitro auth proxy in SSR mode (which moves the refresh token
+ * into an httpOnly cookie).
+ */
+export interface ConvexAuthSignInApi {
+    mutation: (fn: FunctionReference<'mutation'>, args: Record<string, unknown>) => Promise<any>;
+    action: (fn: FunctionReference<'action'>, args: Record<string, unknown>) => Promise<any>;
+}
+/** First-party Convex Auth v2 binding, set by the auth client plugin. */
+export interface ConvexAuthBinding {
+    mode: 'ssr' | 'spa';
+    state: ShallowRef<ConvexAuthSnapshot>;
+    signInApi: ConvexAuthSignInApi;
+    /** Adopt a session returned by a method's sign-in function. */
+    setSession: (session: {
+        accessToken: string;
+        userId: string;
+        [key: string]: unknown;
+    }) => Promise<void>;
+    signOut: () => Promise<void>;
+    /** Values an ambient sign-in (e.g. OAuth) publishes, read reactively. */
+    ambientValue: <T>(id: string, key: string) => Readonly<Ref<T | undefined>>;
+}
 export interface ConvexNuxtContext {
     url: string;
     /**
@@ -25,21 +57,25 @@ export interface ConvexNuxtContext {
      */
     client: ConvexClient | null;
     /**
-     * JWT from the optional auth cookie. Reactive so sign-in/out updates
-     * HttpClient refreshes and `hasSsrSession`.
+     * JWT for HttpClient snapshots: the SSR session token (Convex Auth SSR
+     * mode or a BYO cookie), then the live Convex Auth access token on the
+     * client. Reactive so sign-in/out re-runs HttpClient fetches.
      */
     ssrToken: ComputedRef<string | undefined>;
     /**
      * Shared auth state for useConvexAuth.
      */
     auth: ConvexAuthContext;
+    /**
+     * Convex Auth v2 client binding (`convex.auth.provider: 'convex-auth'`,
+     * browser only). `null` on the server and for BYO providers.
+     */
+    convexAuth?: ConvexAuthBinding | null;
     /**
      * Create a fresh HttpClient for one-shot fetches (SSR / Nitro / refresh).
      * Prefer a new client per call — HttpClient is stateful.
      */
-    createHttpClient: (options?: {
-        token?: string;
-    }) => ConvexHttpClient;
+    createHttpClient: (options?: CreateHttpClientOptions) => ConvexHttpClient;
 }
 export declare const convexNuxtKey: InjectionKey<ConvexNuxtContext>;
 export declare function createAuthContext(): ConvexAuthContext;

package/dist/runtime/utils/http.d.ts

@@ -1,6 +1,13 @@
 import { ConvexHttpClient } from 'convex/browser';
 export interface CreateHttpClientOptions {
     token?: string;
+    /**
+     * Deploy / admin key for privileged HttpClient calls (Next.js
+     * `fetchQuery(..., { adminToken })` parity). Uses `Authorization: Convex …`
+     * and clears any user JWT. Prefer per-request secrets — never put this in
+     * public runtime config.
+     */
+    adminToken?: string;
     skipConvexDeploymentUrlCheck?: boolean;
 }
 /**

package/dist/runtime/utils/http.js

@@ -2,9 +2,12 @@ import { ConvexHttpClient } from "convex/browser";
 export function createHttpClient(url, options = {}) {
   const client = new ConvexHttpClient(url, {
     skipConvexDeploymentUrlCheck: options.skipConvexDeploymentUrlCheck,
-    ...options.token ? { auth: options.token } : {}
+    ...options.token && !options.adminToken ? { auth: options.token } : {}
   });
-  if (options.token) {
+  if (options.adminToken) {
+    ;
+    client.setAdminAuth(options.adminToken);
+  } else if (options.token) {
     client.setAuth(options.token);
   }
   ;

package/dist/types.d.mts

@@ -4,7 +4,7 @@ declare module '@nuxt/schema' {
   interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
 }
 
-export { type AuthTokens, type SignInResult, type UseAuthReturn } from '../dist/runtime/composables/useAuth.js'
+export { type ConvexAuthSession, type ConvexSignInResult, type OAuthCompleteResult, type OAuthFlowError, type OAuthProviderRefs, type OAuthSignInOptions, type OAuthStartResult, type UseAuthReturn } from '../dist/runtime/composables/useAuth.js'
 
 export { type ConvexQueryArgs, type UseConvexQueryOptions, type UseConvexQueryReturn } from '../dist/runtime/composables/useConvexQuery.js'
 
@@ -18,7 +18,7 @@ export { type ConvexR2UploadApi, type ConvexR2UploadProgress } from '../dist/run
 
 export { type PaginatedQueryArgs, type PaginatedQueryItem, type PaginatedQueryReference, type PaginationStatus, type UseConvexPaginatedQueryOptions, type UseConvexPaginatedQueryReturn } from '../dist/runtime/composables/useConvexPaginatedQuery.js'
 
-export { type ConvexQueriesRequest, type ConvexQueriesResult, type ConvexQueryRequestEntry } from '../dist/runtime/composables/useConvexQueries.js'
+export { type ConvexQueriesRequest, type ConvexQueriesResult, type ConvexQueryRequestEntry, type UseConvexQueriesOptions } from '../dist/runtime/composables/useConvexQueries.js'
 
 export { type ConvexFetchOptions } from '../dist/runtime/server/fetch.js'
 
@@ -30,6 +30,10 @@ export { type ConnectionState } from '../dist/runtime/composables/useConvexConne
 
 export { type ConvexGate } from '../dist/runtime/composables/useConvexGate.js'
 
+export { type ConvexAmbientSignIn, type ConvexAuthClientOptions, type ConvexAuthStorageMode, type ConvexAuthTokenStorage, type configureConvexAuth } from '../dist/runtime/utils/authClientOptions.js'
+
+export { type ConvexAuthServerRuntimeConfig } from '../dist/runtime/utils/authStorage.js'
+
 export { default } from './module.mjs'
 
 export { type ModuleAuthOptions, type ModuleOptions, type ModulePublicRuntimeConfig } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "use-convex",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "First-class Convex integration for Nuxt",
   "license": "MIT",
   "repository": {
@@ -44,13 +44,12 @@
     "h3": "^1.15.0"
   },
   "devDependencies": {
-    "@auth/core": "0.41.1",
-    "@convex-dev/auth": "^0.0.95",
+    "@convex-dev/auth": "^2.0.0",
     "@nuxt/module-builder": "^1.0.0",
     "@nuxt/schema": "^4.0.0",
     "@nuxt/test-utils": "^3.23.0",
     "@types/node": "^26.5.0",
-    "convex": "^1.46.0",
+    "convex": "^1.48.0",
     "convex-test": "^0.0.56",
     "happy-dom": "^20.14.0",
     "nitropack": "^2.13.0",
@@ -63,10 +62,16 @@
     "vue-tsc": "^3.0.0"
   },
   "peerDependencies": {
-    "convex": "^1.46.0",
+    "@convex-dev/auth": "^2.0.0",
+    "convex": "^1.48.0",
     "nuxt": "^4.0.0",
     "vue": "^3.5.0"
   },
+  "peerDependenciesMeta": {
+    "@convex-dev/auth": {
+      "optional": true
+    }
+  },
   "packageManager": "pnpm@10.0.0",
   "pnpm": {
     "overrides": {