nuxt-convex-module 0.0.0 → 0.9.0

package/dist/runtime/better-auth/nuxt/proxy.d.ts

@@ -1,6 +1,22 @@
 /**
- * Proxy all /api/auth/* requests to the Convex site URL.
- * This keeps auth cookies on the same origin (no CORS issues).
+ * Proxy all `${convex.authRoute}/**` requests (default `/api/auth/**`) to the
+ * Convex site URL. This keeps auth cookies on the same origin (no CORS issues).
+ *
+ * The site URL is `convexAuth`'s to resolve: the private `runtimeConfig.convex.siteUrl`,
+ * then the public one, then the environment — so a container built without it and
+ * started with `NUXT_PUBLIC_CONVEX_SITE_URL` works. Reading only the private key here
+ * used to fail every auth request in exactly that deployment.
+ *
+ * The method list matches the nuxt-security route rule the module registers on this
+ * route; enforcing it here too keeps the proxy closed to `PUT`/`DELETE` probes when
+ * nuxt-security is not installed.
+ *
+ * The path check: h3 routes the request's raw path, and the handler forwards the
+ * URL-normalised one. `/api/auth/../../x` (or its `%2e%2e` spelling) matches this
+ * route and normalises to `/x`, which the proxy would send to the site origin —
+ * any HTTP action on the deployment, reached through the app's origin with the
+ * app's cookies attached. Next.js normalises before routing, so upstream's
+ * handler never sees such a path; Nitro does not, so it is refused here.
  */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<Response>>;
 export default _default;

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

@@ -1,11 +1,11 @@
-import { defineEventHandler } from "h3";
-import { useRuntimeConfig } from "#imports";
+import { assertMethod, createError, defineEventHandler, toWebRequest } from "h3";
 import { convexAuth } from "./server.js";
 export default defineEventHandler(async (event) => {
-  const config = useRuntimeConfig();
-  const siteUrl = config.convex.siteUrl;
-  if (!siteUrl) {
-    throw new Error("[nuxt-convex-module] NUXT_PUBLIC_CONVEX_SITE_URL is not configured. Auth proxy cannot forward requests.");
+  assertMethod(event, ["GET", "HEAD", "POST", "OPTIONS"]);
+  const routed = event.path.split("?")[0];
+  const forwarded = new URL(toWebRequest(event).url).pathname;
+  if (forwarded !== routed) {
+    throw createError({ statusCode: 400, statusMessage: "Bad Request" });
   }
-  return convexAuth(event, { convexSiteUrl: siteUrl }).handler();
+  return convexAuth(event).handler();
 });

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

@@ -1,11 +1,9 @@
 /**
  * Server-side Better Auth + Convex integration for Nuxt.
  *
- * Provides {@link convexAuth} for Nuxt server handlers.
- *
- * It accepts the H3
- * {@link H3Event} that is available in every Nuxt server route, API handler
- * and server middleware.
+ * Provides {@link convexAuth} for Nuxt server handlers: it takes the H3
+ * `H3Event` every Nuxt server route, API handler and server middleware
+ * receives, and returns a request-scoped, authenticated Convex client.
  *
  * @module better-auth/server
  */
@@ -30,7 +28,9 @@ export type ConvexAuthOptions = GetTokenOptions & {
      */
     convexUrl?: string;
     /**
-     * Override the Convex site URL. Defaults to `NUXT_PUBLIC_CONVEX_SITE_URL`.
+     * Override the Convex site URL. Defaults to `runtimeConfig.convex.siteUrl`,
+     * then `runtimeConfig.public.convex.siteUrl`, then the
+     * `NUXT_PUBLIC_CONVEX_SITE_URL` process variable.
      */
     convexSiteUrl?: string;
 };

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

@@ -11,6 +11,21 @@ const parseConvexSiteUrl = (url) => {
   if (url.endsWith(".convex.cloud")) {
     throw new Error(
       `NUXT_PUBLIC_CONVEX_SITE_URL should be set to your Convex Site URL, which ends in .convex.site.
+Currently set to ${url}.`
+    );
+  }
+  let protocol;
+  try {
+    protocol = new URL(url).protocol;
+  } catch {
+    throw new Error(
+      `NUXT_PUBLIC_CONVEX_SITE_URL must be an absolute URL, including the scheme.
+Currently set to ${url}.`
+    );
+  }
+  if (protocol !== "https:" && protocol !== "http:") {
+    throw new Error(
+      `NUXT_PUBLIC_CONVEX_SITE_URL must use http: or https:.
 Currently set to ${url}.`
     );
   }

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

@@ -1,7 +1,7 @@
 import { type PropType, type VNode } from 'vue';
 import type { FunctionReference } from 'convex/server';
-import type { EmptyObject } from 'convex-helpers';
 import type { AuthClient } from '#convex/auth-client';
+type EmptyObject = Record<string, never>;
 /**
  * _Experimental_
  *
@@ -43,6 +43,7 @@ import type { AuthClient } from '#convex/auth-client';
  * @param props.isAuthError - Function to check if the error is auth related.
  *
  * @public
+ * @experimental May change in a minor release — see STABILITY.md.
  */
 export declare const AuthBoundary: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
     /**
@@ -129,3 +130,4 @@ export declare const AuthBoundary: import("vue").DefineComponent<import("vue").E
 }>> & Readonly<{}>, {
     renderFallback: () => VNode | null;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export {};

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

@@ -172,7 +172,7 @@ export declare const authClient: import("better-auth/vue").VueAuthClient<{
                     metadata: {
                         isAction: false;
                     };
-                }, import("better-auth/plugins").OIDCMetadata>;
+                }, import("better-auth/plugins/oidc-provider").OIDCMetadata>;
                 getJwks: import("better-auth").StrictEndpoint<"/convex/jwks", {
                     method: "GET";
                     metadata: {

package/dist/runtime/better-auth/vue/cross-domain.d.ts

@@ -11,11 +11,10 @@ export interface ConsumeCrossDomainOneTimeTokenOptions {
      *
      * The cross-domain protocol cannot bind the token to the browser that
      * started the sign-in flow (magic-link flows legitimately finish in another
-     * browsing context), so without this restriction a crafted
-     * `/any-page?ott=…` link silently signs the visitor into the link author's
-     * session — login CSRF. Restricting consumption to the one route your
-     * sign-in `callbackURL`s point at shrinks that surface to a single
-     * predictable URL.
+     * browsing context), so without this restriction a token completes sign-in
+     * on whatever page receives it. Restricting consumption to the one route
+     * your sign-in `callbackURL`s point at keeps that to a single predictable
+     * URL.
      *
      * In Nuxt, set `convex.betterAuth.crossDomainCallbackRoute` instead — the
      * client plugin forwards it here.

package/dist/runtime/better-auth/vue/cross-domain.js

@@ -1,7 +1,9 @@
 import { authClient } from "#convex/auth-client";
 const normalizePathname = (path) => {
   const slashed = path.startsWith("/") ? path : `/${path}`;
-  const trimmed = slashed.replace(/\/+$/, "");
+  let end = slashed.length;
+  while (end > 0 && slashed[end - 1] === "/") end--;
+  const trimmed = slashed.slice(0, end);
   return trimmed === "" ? "/" : trimmed;
 };
 export async function consumeCrossDomainOneTimeToken(options = {}) {
@@ -19,10 +21,15 @@ export async function consumeCrossDomainOneTimeToken(options = {}) {
     }
     if (options.callbackRoute && normalizePathname(url.pathname) !== normalizePathname(options.callbackRoute)) {
       console.warn(
-        `[nuxt-convex-module] ignoring cross-domain one-time token on "${url.pathname}" \u2014 consumption is restricted to "${options.callbackRoute}" (convex.betterAuth.crossDomainCallbackRoute).`
+        `[nuxt-convex-module] Ignoring cross-domain one-time token on "${url.pathname}" \u2014 consumption is restricted to "${options.callbackRoute}" (convex.betterAuth.crossDomainCallbackRoute).`
       );
       return;
     }
+    if (import.meta.dev && !options.callbackRoute) {
+      console.warn(
+        `[nuxt-convex-module] Exchanged a cross-domain one-time token on "${url.pathname}" with no \`convex.betterAuth.crossDomainCallbackRoute\` set \u2014 any page can complete sign-in. Restrict it to your callback route.`
+      );
+    }
     try {
       const result = await authClientWithCrossDomain.crossDomain.oneTimeToken.verify({
         token
@@ -36,10 +43,10 @@ export async function consumeCrossDomainOneTimeToken(options = {}) {
             }
           }
         });
-        authClientWithCrossDomain.updateSession();
+        await authClientWithCrossDomain.updateSession();
       }
     } catch (error) {
-      console.warn("[nuxt-convex-module] failed to consume cross-domain one-time token", error);
+      console.warn("[nuxt-convex-module] Failed to consume cross-domain one-time token:", error);
     }
   }
 }

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

@@ -2,7 +2,7 @@ import type { FunctionReference } from 'convex/server';
 import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
 import { type Preloaded } from '../../vue/hydration.js';
 /**
- * Auth-aware version of {@link usePreloadedQuery} for payloads returned by
+ * Auth-aware version of {@link client!usePreloadedQuery | usePreloadedQuery} for payloads returned by
  * `convexAuth(event).preloadAuthQuery(...)`.
  *
  * A Vue/Nuxt port of `@convex-dev/better-auth`'s `usePreloadedAuthQuery`

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

@@ -4,9 +4,10 @@
  *
  * @module better-auth/client
  */
-export { useAuth, type UseAuthService, type AuthSession, type AuthUser } from './use-auth.js';
+export { useBetterAuth, type UseBetterAuthReturn, type BetterAuthSession, type BetterAuthUser } from './use-better-auth.js';
 export { authClient, type AuthClient } from '#convex/auth-client';
 export { usePreloadedAuthQuery } from './hydration.js';
 export { consumeCrossDomainOneTimeToken, type ConsumeCrossDomainOneTimeTokenOptions } from './cross-domain.js';
+export { resolveAuthRedirect } from './redirect.js';
 export { AuthBoundary } from './auth-boundary.js';
 export { convexClient, crossDomainClient } from '@convex-dev/better-auth/client/plugins';

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

@@ -1,6 +1,7 @@
-export { useAuth } from "./use-auth.js";
+export { useBetterAuth } from "./use-better-auth.js";
 export { authClient } from "#convex/auth-client";
 export { usePreloadedAuthQuery } from "./hydration.js";
 export { consumeCrossDomainOneTimeToken } from "./cross-domain.js";
+export { resolveAuthRedirect } from "./redirect.js";
 export { AuthBoundary } from "./auth-boundary.js";
 export { convexClient, crossDomainClient } from "@convex-dev/better-auth/client/plugins";

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

@@ -1,6 +1,2 @@
-import { ConvexVueClient } from '../../vue/client.js';
-type ConvexNuxtInjection = {
-    convex?: ConvexVueClient;
-};
-declare const _default: import("nuxt/app").Plugin<ConvexNuxtInjection> & import("nuxt/app").ObjectPlugin<ConvexNuxtInjection>;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/better-auth/vue/plugin.client.js

@@ -1,32 +1,28 @@
 import { defineNuxtPlugin, useRuntimeConfig, useState } from "#app";
 import { ConvexVueClient, ConvexClientKey } from "../../vue/client.js";
 import { ConvexAuthStateKey, createScopedConvexAuthState } from "../../vue/auth/index.js";
-import { useAuth } from "./use-auth.js";
+import { CONVEX_INITIAL_TOKEN_KEY } from "../../nuxt/config.js";
+import { useBetterAuth } from "./use-better-auth.js";
 import { consumeCrossDomainOneTimeToken } from "./cross-domain.js";
 export default defineNuxtPlugin({
   name: "nuxt-convex-module:better-auth:client",
   async setup(nuxtApp) {
     const { url, crossDomainCallbackRoute } = useRuntimeConfig().public.convex;
     if (!url) {
-      console.warn("[nuxt-convex-module] No Convex URL configured for client plugin.");
-      return { provide: {} };
+      console.warn("[nuxt-convex-module] No Convex deployment URL configured \u2014 client and auth not created. Set NUXT_PUBLIC_CONVEX_URL or `convex.url` in nuxt.config.");
+      return;
     }
     const client = new ConvexVueClient(url);
     nuxtApp.vueApp.provide(ConvexClientKey, client);
     await consumeCrossDomainOneTimeToken({
       callbackRoute: crossDomainCallbackRoute || void 0
     });
-    const initialToken = useState("convex:initialToken", () => null);
+    const initialToken = useState(CONVEX_INITIAL_TOKEN_KEY, () => null);
     const { state, scope } = createScopedConvexAuthState({
       client,
-      useAuth: () => useAuth(initialToken.value)
+      useAuth: () => useBetterAuth(initialToken.value)
     });
     nuxtApp.vueApp.provide(ConvexAuthStateKey, state);
     void scope;
-    return {
-      provide: {
-        convex: client
-      }
-    };
   }
 });

package/dist/runtime/better-auth/vue/plugin.server.d.ts

@@ -1,24 +1,13 @@
-import { useState, useRequestEvent } from '#app';
-import { ConvexVueClient } from '../../vue/client.js';
-type ConvexNuxtInjection = {
-    convex?: ConvexVueClient;
-};
-/**
- * Prefetch the Convex JWT for SSR and stash it in `initialToken`.
- *
- * Exported for unit testing.
- */
-export declare function prefetchAuthToken(event: ReturnType<typeof useRequestEvent>, initialToken: ReturnType<typeof useState<string | null>>): Promise<void>;
 /**
  * Server-side Better Auth bootstrap.
  *
  * Mirrors the Next.js parity layer that calls `getToken()` from the root
  * server layout and passes it as `initialToken` to `ConvexBetterAuthProvider`.
  *
- * The token is stashed into a Nuxt `useState('convex:initialToken')` so the
- * client plugin can hand it to `useAuth(initialToken)` before the first
- * Convex `setAuth` call — avoiding an extra Better Auth round-trip on first
- * paint.
+ * The token is stashed into a Nuxt `useState` (`CONVEX_INITIAL_TOKEN_KEY`) so
+ * the client plugin can hand it to `useBetterAuth(initialToken)` before the
+ * first Convex `setAuth` call — avoiding an extra Better Auth round-trip on
+ * first paint.
  */
-declare const _default: import("nuxt/app").Plugin<ConvexNuxtInjection> & import("nuxt/app").ObjectPlugin<ConvexNuxtInjection>;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/better-auth/vue/plugin.server.js

@@ -2,11 +2,9 @@ import { computed } from "vue";
 import { setResponseHeader } from "h3";
 import { defineNuxtPlugin, useRuntimeConfig, useState, useRequestEvent } from "#app";
 import { ConvexVueClient, ConvexClientKey } from "../../vue/client.js";
+import { CONVEX_INITIAL_TOKEN_KEY } from "../../nuxt/config.js";
 import { convexAuth } from "../nuxt/server.js";
 import { ConvexAuthStateKey } from "../../vue/auth/index.js";
-function buildProvide(ssrClient) {
-  return ssrClient ? { provide: { convex: ssrClient } } : { provide: {} };
-}
 export async function prefetchAuthToken(event, initialToken) {
   try {
     const token = await convexAuth(event).getToken();
@@ -21,7 +19,7 @@ export async function prefetchAuthToken(event, initialToken) {
 export default defineNuxtPlugin({
   name: "nuxt-convex-module:better-auth:server",
   async setup(nuxtApp) {
-    const initialToken = useState("convex:initialToken", () => null);
+    const initialToken = useState(CONVEX_INITIAL_TOKEN_KEY, () => null);
     const url = useRuntimeConfig().public.convex.url;
     const ssrClient = url ? new ConvexVueClient(url) : void 0;
     if (ssrClient) {
@@ -34,9 +32,8 @@ export default defineNuxtPlugin({
     };
     nuxtApp.vueApp.provide(ConvexAuthStateKey, ssrAuthState);
     const event = useRequestEvent();
-    if (event) {
+    if (event && !import.meta.prerender) {
       await prefetchAuthToken(event, initialToken);
     }
-    return buildProvide(ssrClient);
   }
 });

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

@@ -0,0 +1,33 @@
+/**
+ * Validate a post-sign-in redirect destination, returning `fallback` unless it
+ * is a same-origin path.
+ *
+ * Use it wherever a login page consumes the `?redirect=` query the `auth`
+ * middleware sets — never navigate to that value directly.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const route = useRoute()
+ * const { client } = useBetterAuth()
+ *
+ * async function onSubmit() {
+ *   await client.signIn.email({ email, password })
+ *   // '/dashboard' survives; 'https://evil.example' becomes '/'.
+ *   await navigateTo(resolveAuthRedirect(route.query.redirect))
+ * }
+ * </script>
+ * ```
+ *
+ * @param value - Candidate destination, typically `route.query.redirect`. A
+ *   repeated query parameter arrives as an array and is rejected: which entry
+ *   the app meant is ambiguous, and an attacker chooses the other one.
+ * @param fallback - Where to send the visitor when `value` is not a safe
+ *   same-origin path. Defaults to `/`, and is returned as given — pass a path
+ *   you control, not user input.
+ *
+ * @returns The normalized `pathname + search + hash`, or `fallback`.
+ *
+ * @public
+ */
+export declare function resolveAuthRedirect(value: unknown, fallback?: string): string;

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

@@ -0,0 +1,14 @@
+const SENTINEL_ORIGIN = "http://redirect.invalid";
+export function resolveAuthRedirect(value, fallback = "/") {
+  if (typeof value !== "string" || value === "") return fallback;
+  if (!value.startsWith("/")) return fallback;
+  try {
+    const url = new URL(value, SENTINEL_ORIGIN);
+    if (url.origin !== SENTINEL_ORIGIN) return fallback;
+    const path = `${url.pathname}${url.search}${url.hash}`;
+    if (new URL(path, SENTINEL_ORIGIN).origin !== SENTINEL_ORIGIN) return fallback;
+    return path;
+  } catch {
+    return fallback;
+  }
+}

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

@@ -27,7 +27,9 @@ declare const useClientSession: () => Readonly<import("vue").Ref<{
     readonly isPending: boolean;
     readonly isRefetching: boolean;
     readonly error: import("better-auth/client").BetterFetchError | null;
-    readonly refetch: (queryParams?: {
+    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>;
 }, {
@@ -56,37 +58,55 @@ declare const useClientSession: () => Readonly<import("vue").Ref<{
     readonly isPending: boolean;
     readonly isRefetching: boolean;
     readonly error: import("better-auth/client").BetterFetchError | null;
-    readonly refetch: (queryParams?: {
+    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 AuthSession = ReturnType<typeof useClientSession>;
+export type BetterAuthSession = ReturnType<typeof useClientSession>;
 /** The signed-in user (loose — exact fields depend on your auth schema). */
-export type AuthUser = {
+export type BetterAuthUser = {
     id: string;
     email: string;
     name: string;
 } & Record<string, unknown>;
-export interface UseAuthService {
+/** What `useBetterAuth()` returns. */
+export interface UseBetterAuthReturn {
+    /** `true` until the session is known and no prefetched token covers the gap. */
     isLoading: ComputedRef<boolean>;
+    /** `true` when Better Auth reports a session, or a token is cached while it reloads. */
     isAuthenticated: ComputedRef<boolean>;
+    /** Convex's token fetcher: the Better Auth JWT for the current session, or `null`. */
     fetchAccessToken: AuthTokenFetcher;
+    /** The Better Auth client from `#convex/auth-client` — sign-in, sign-out and every plugin flow live here. */
     client: AuthClient;
-    session: AuthSession;
+    /** Better Auth's own `useSession()` ref: `{ data, isPending, error }`. */
+    session: BetterAuthSession;
     /** The current user, or `null` when signed out / still loading. */
-    user: ComputedRef<AuthUser | null>;
+    user: ComputedRef<BetterAuthUser | null>;
+    /** The session id (or user id); changes when the signed-in identity changes. */
     authVersion: ComputedRef<string | null>;
 }
 /**
- * Unified Better Auth service for the Vue/Nuxt runtime.
+ * The Better Auth service for the Vue/Nuxt runtime.
  *
  * Returns the full Better Auth client, the reactive session wrapper, and the
  * Convex-compatible auth state used by the packaged auth plugin.
  *
  * @param initialToken - Optional preloaded token, used once per app lifetime
  *   to avoid a round-trip on initial load (e.g. from SSR).
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ * const { user, client, isAuthenticated } = useBetterAuth()
+ *
+ * const signOut = () => client.signOut()
+ * </script>
+ * ```
+ *
+ * @public
  */
-export declare function useAuth(initialToken?: string | null): UseAuthService;
-/** Reset module-level token cache — intended for tests only. */
-export declare function __resetUseAuthForTests(): void;
+export declare function useBetterAuth(initialToken?: string | null): UseBetterAuthReturn;
 export {};

package/dist/runtime/better-auth/vue/{use-auth.js → use-better-auth.js}

@@ -7,7 +7,7 @@ let pendingTokenVersion = null;
 let initialTokenUsed = false;
 const PENDING_AUTH_VERSION = "__pending__";
 const useClientSession = () => authClient.useSession();
-export function useAuth(initialToken) {
+export function useBetterAuth(initialToken) {
   if (!initialTokenUsed && initialToken) {
     cachedToken.value = initialToken;
     cachedTokenVersion = PENDING_AUTH_VERSION;
@@ -55,6 +55,7 @@ export function useAuth(initialToken) {
   };
   return {
     isLoading: computed(() => session.value.isPending && !cachedToken.value),
+    // PARITY: D-03
     // Diverges from upstream's `Boolean(session?.session) || cachedToken !== null`:
     // a settled signed-out session must read unauthenticated immediately (Vue has
     // no re-render to run upstream's cache-clearing effect first), and Better Auth
@@ -63,7 +64,7 @@ export function useAuth(initialToken) {
       () => !!session.value.data || session.value.isPending && cachedToken.value !== null
     ),
     fetchAccessToken,
-    // Vue-only service extensions (documented in PARITY.md).
+    // PARITY: A-06 — Vue-only service extensions.
     client,
     session,
     user: computed(() => {
@@ -73,7 +74,7 @@ export function useAuth(initialToken) {
     authVersion
   };
 }
-export function __resetUseAuthForTests() {
+export function __resetUseBetterAuthForTests() {
   cachedToken.value = null;
   cachedTokenVersion = null;
   pendingToken = null;

package/dist/runtime/clerk/vue/index.d.ts

@@ -16,15 +16,15 @@ export type UseAuth = () => {
  * Options for {@link provideConvexAuthFromClerk} / `<ConvexProviderWithClerk>`.
  */
 export interface ConvexProviderWithClerkOptions {
-    /** Convex client to authenticate. Defaults to the provided {@link useConvex} client. */
+    /** Convex client to authenticate. Defaults to the client `useConvex()` returns. */
     client?: IConvexVueClient;
     /** Clerk's `useAuth` composable. Defaults to `useAuth` from `@clerk/vue`. */
     useAuth?: UseAuth;
 }
 /**
- * A composable which provides a {@link ConvexVueClient}
+ * A composable which provides a {@link client!ConvexVueClient | ConvexVueClient}
  * authenticated with Clerk, exposing the reactive auth state to descendants
- * via {@link useConvexAuth} — the Vue translation of wrapping the app in
+ * via {@link client!useConvexAuth | useConvexAuth} — the Vue translation of wrapping the app in
  * `convex/react-clerk`'s `<ConvexProviderWithClerk>`.
  *
  * Call it in a top-level component's `setup`. The app must be wrapped by a
@@ -47,7 +47,7 @@ export interface ConvexProviderWithClerkOptions {
  */
 export declare function provideConvexAuthFromClerk(options?: ConvexProviderWithClerkOptions): ConvexAuthState;
 /**
- * A wrapper Vue component which provides a {@link ConvexVueClient}
+ * A wrapper Vue component which provides a {@link client!ConvexVueClient | ConvexVueClient}
  * authenticated with Clerk — the component form of
  * {@link provideConvexAuthFromClerk}, kept as a drop-in parity port of
  * `convex/react-clerk`'s `<ConvexProviderWithClerk>`. Renders its default

package/dist/runtime/devtools/bridge.js

@@ -17,7 +17,7 @@ function toPlainJson(value) {
   try {
     return convexToJson(value);
   } catch {
-    return String(value);
+    return typeof value === "object" && value !== null ? `[unserializable ${Array.isArray(value) ? "array" : "object"}]` : String(value);
   }
 }
 function renderLogArg(arg) {

package/dist/runtime/nuxt/app.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Composables that need the Nuxt app context (`#app`) — the half of the
+ * package that runs in a Nuxt app but not in plain Vue.
+ *
+ * This module contains {@link useAsyncQuery} and its paginated form
+ * {@link useAsyncPaginatedQuery}: server-rendered Convex data that upgrades
+ * to a live subscription after hydration.
+ *
+ * ## Usage
+ *
+ * **Default — auto-imported.** In any page, component or composable, call it
+ * with no import; its types are auto-imported too:
+ *
+ * ```vue
+ * <script setup lang="ts">
+ * import { api } from '#convex/api'
+ *
+ * const { data: messages, status } = useAsyncQuery(api.messages.list, {})
+ * // `AsyncQueryStatus`, `AsyncQueryReturn`, … resolve without an import as well:
+ * const label = (s: AsyncQueryStatus) => s === 'pending' ? 'Loading…' : ''
+ * </script>
+ * ```
+ *
+ * **Explicit import — this subpath.** For a project that turns auto-imports
+ * off, a file outside the app's auto-import scope, or an editor that wants
+ * the import spelled out:
+ *
+ * ```ts
+ * import { useAsyncQuery } from 'nuxt-convex-module/app'
+ * ```
+ *
+ * **Types.** From `#imports` (Nuxt's auto-import barrel) or from this subpath,
+ * whichever your file already uses:
+ *
+ * ```ts
+ * import type { AsyncQueryReturn } from '#imports'
+ * import type { AsyncQueryReturn } from 'nuxt-convex-module/app'
+ *
+ * const messages: AsyncQueryReturn<Doc<'messages'>[]> = useAsyncQuery(api.messages.list, {})
+ * ```
+ *
+ * Before 1.0 the composable was auto-imported but reachable from no subpath,
+ * so neither the explicit form nor the types could be written at all.
+ *
+ * @module app
+ */
+export { useAsyncQuery, useConvexAsyncQuery, type AsyncQueryData, type AsyncQueryOptions, type AsyncQueryReturn, type AsyncQueryStatus, } from './composables/use-async-query.js';
+export { useAsyncPaginatedQuery, useConvexAsyncPaginatedQuery, type AsyncPaginatedQueryData, type AsyncPaginatedQueryOptions, type AsyncPaginatedQueryReturn, } from './composables/use-async-paginated-query.js';

package/dist/runtime/nuxt/app.js

@@ -0,0 +1,8 @@
+export {
+  useAsyncQuery,
+  useConvexAsyncQuery
+} from "./composables/use-async-query.js";
+export {
+  useAsyncPaginatedQuery,
+  useConvexAsyncPaginatedQuery
+} from "./composables/use-async-paginated-query.js";