use-convex 0.0.2 → 1.0.0

package/dist/runtime/composables/useConvexMutation.js

@@ -1,35 +1,25 @@
-import { computed, ref, toValue } from "vue";
+import { toValue } from "vue";
 import { useConvexContext } from "../utils/context.js";
+import { createPendingErrorState } from "../utils/pendingError.js";
 export function useConvexMutation(mutation, options = {}) {
   const ctx = useConvexContext();
-  const error = ref(null);
-  const pendingCount = ref(0);
+  const { error, pending, withPending } = createPendingErrorState();
   const mutate = async (args = {}) => {
     if (import.meta.server || !ctx.client) {
-      throw new Error(
-        "[convex-nuxt] useConvexMutation can only run in the browser."
-      );
+      throw new Error("[use-convex] useConvexMutation can only run in the browser.");
     }
-    pendingCount.value++;
-    error.value = null;
-    try {
+    return await withPending(async () => {
       const resolved = toValue(args);
       return await ctx.client.mutation(
         mutation,
         resolved,
         options.optimisticUpdate ? { optimisticUpdate: options.optimisticUpdate } : void 0
       );
-    } catch (cause) {
-      const err = cause instanceof Error ? cause : new Error(String(cause));
-      error.value = err;
-      throw err;
-    } finally {
-      pendingCount.value--;
-    }
+    });
   };
   return {
     mutate,
     error,
-    pending: computed(() => pendingCount.value > 0)
+    pending
   };
 }

package/dist/runtime/composables/useConvexPaginatedQuery.d.ts

@@ -6,7 +6,7 @@ import { type ComputedRef, type MaybeRefOrGetter, type Ref } from 'vue';
  */
 export type PaginatedQueryReference = FunctionReference<'query', 'public', {
     paginationOpts: PaginationOptions;
-}, PaginationResult<any>>;
+}, PaginationResult<unknown>>;
 export type PaginatedQueryArgs<Query extends PaginatedQueryReference> = Omit<FunctionArgs<Query>, 'paginationOpts'>;
 export type PaginatedQueryItem<Query extends PaginatedQueryReference> = FunctionReturnType<Query>['page'][number];
 export type PaginationStatus = 'LoadingFirstPage' | 'CanLoadMore' | 'LoadingMore' | 'Exhausted';

package/dist/runtime/composables/useConvexPaginatedQuery.js

@@ -1,5 +1,5 @@
 import { convexToJson, jsonToConvex } from "convex/values";
-import { useAsyncData, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+import { useAsyncData, useRuntimeConfig } from "nuxt/app";
 import {
   computed,
   onScopeDispose,
@@ -10,24 +10,11 @@ import {
 } from "vue";
 import { resolveAuthGatedArgs } from "../utils/authGate.js";
 import { useConvexContext } from "../utils/context.js";
+import { readHydratedPayloadCache } from "../utils/payloadCache.js";
 import { convexQueryKey } from "../utils/queryKey.js";
-function mapLiveStatus(status) {
-  switch (status) {
-    case "LoadingFirstPage":
-      return "LoadingFirstPage";
-    case "LoadingMore":
-      return "LoadingMore";
-    case "Exhausted":
-      return "Exhausted";
-    case "CanLoadMore":
-      return "CanLoadMore";
-  }
-}
 export async function useConvexPaginatedQuery(query, args = {}, options) {
   if (options.initialNumItems <= 0) {
-    throw new Error(
-      "[convex-nuxt] useConvexPaginatedQuery initialNumItems must be > 0"
-    );
+    throw new Error("[use-convex] useConvexPaginatedQuery initialNumItems must be > 0");
   }
   const runtimeConfig = useRuntimeConfig();
   const defaultServer = runtimeConfig.public.convex?.server;
@@ -63,15 +50,10 @@ export async function useConvexPaginatedQuery(query, args = {}, options) {
       }
       const token = options.token ?? ctx.ssrToken.value;
       if (requireAuth && import.meta.client && !token) {
-        const nuxtApp = useNuxtApp();
-        const cached = nuxtApp.payload.data[toValue(key)];
-        return cached ?? null;
+        return readHydratedPayloadCache(key);
       }
       const http = ctx.createHttpClient({ token });
-      const result = await http.query(
-        query,
-        pageArgs
-      );
+      const result = await http.query(query, pageArgs);
       return jsonToConvex(convexToJson(result));
     },
     {
@@ -104,7 +86,7 @@ export async function useConvexPaginatedQuery(query, args = {}, options) {
       return "Exhausted";
     }
     if (liveReady.value && live.value) {
-      return mapLiveStatus(live.value.status);
+      return live.value.status;
     }
     if (asyncData.pending.value || import.meta.client && !liveReady.value) {
       if (asyncData.data.value) {
@@ -153,11 +135,7 @@ export async function useConvexPaginatedQuery(query, args = {}, options) {
       );
     };
     watch(
-      () => [
-        toValue(args),
-        options.initialNumItems,
-        ctx.auth.isAuthenticated.value
-      ],
+      () => [toValue(args), options.initialNumItems, ctx.auth.isAuthenticated.value],
       subscribe,
       { immediate: true }
     );

package/dist/runtime/composables/useConvexQueries.d.ts

@@ -1,14 +1,19 @@
-import type { FunctionReference, FunctionReturnType } from 'convex/server';
-import type { Value } from 'convex/values';
+import type { FunctionArgs, FunctionReference, FunctionReturnType } from 'convex/server';
 import { type ComputedRef, type MaybeRefOrGetter } from 'vue';
-export type ConvexQueriesRequest = Record<string, {
-    query: FunctionReference<'query'>;
-    args: Record<string, Value>;
-} | 'skip'>;
+/** One entry in a {@link useConvexQueries} request map. */
+export type ConvexQueryRequestEntry<Query extends FunctionReference<'query'> = FunctionReference<'query'>> = {
+    query: Query;
+    args: FunctionArgs<Query>;
+};
+/**
+ * Request map for {@link useConvexQueries}.
+ * Values are `{ query, args }` or `'skip'`.
+ */
+export type ConvexQueriesRequest = Record<string, ConvexQueryRequestEntry | 'skip'>;
 export type ConvexQueriesResult<Request extends ConvexQueriesRequest> = {
     [K in keyof Request]: Request[K] extends {
         query: infer Query;
-        args: any;
+        args: infer _Args;
     } ? Query extends FunctionReference<'query'> ? FunctionReturnType<Query> | undefined | Error : undefined : undefined;
 };
 /**

package/dist/runtime/composables/useConvexQueries.js

@@ -15,9 +15,7 @@ export function useConvexQueries(queries) {
   const ctx = useConvexContext();
   const results = shallowRef({});
   if (import.meta.server || !ctx.client) {
-    return computed(
-      () => results.value
-    );
+    return computed(() => results.value);
   }
   const client = ctx.client;
   const unsubscribers = /* @__PURE__ */ new Map();

package/dist/runtime/composables/useConvexQuery.js

@@ -1,5 +1,5 @@
 import { convexToJson, jsonToConvex } from "convex/values";
-import { useAsyncData, useNuxtApp, useRuntimeConfig } from "nuxt/app";
+import { useAsyncData, useRuntimeConfig } from "nuxt/app";
 import {
   computed,
   onScopeDispose,
@@ -10,6 +10,7 @@ import {
 import { resolveAuthGatedArgs } from "../utils/authGate.js";
 import { useConvexContext } from "../utils/context.js";
 import { resolveQueryOverlay } from "../utils/overlay.js";
+import { readHydratedPayloadCache } from "../utils/payloadCache.js";
 import { convexQueryKey } from "../utils/queryKey.js";
 export async function useConvexQuery(query, args = {}, options = {}) {
   const runtimeConfig = useRuntimeConfig();
@@ -23,9 +24,7 @@ export async function useConvexQuery(query, args = {}, options = {}) {
     authenticated: requireAuth,
     isAuthenticated: ctx.auth.isAuthenticated.value
   });
-  const key = computed(
-    () => convexQueryKey(query, resolveRawArgs(), options.key)
-  );
+  const key = computed(() => convexQueryKey(query, resolveRawArgs(), options.key));
   const asyncData = await useAsyncData(
     key,
     async () => {
@@ -35,15 +34,10 @@ export async function useConvexQuery(query, args = {}, options = {}) {
       }
       const token = options.token ?? ctx.ssrToken.value;
       if (requireAuth && import.meta.client && !token) {
-        const nuxtApp = useNuxtApp();
-        const cached = nuxtApp.payload.data[toValue(key)];
-        return cached ?? null;
+        return readHydratedPayloadCache(key);
       }
       const http = ctx.createHttpClient({ token });
-      const result = await http.query(
-        query,
-        argsValue ?? {}
-      );
+      const result = await http.query(query, argsValue ?? {});
       return jsonToConvex(convexToJson(result));
     },
     {
@@ -87,7 +81,7 @@ export async function useConvexQuery(query, args = {}, options = {}) {
   }
   const client = ctx.client;
   if (!client) {
-    throw new Error("[convex-nuxt] ConvexClient is not available on the client.");
+    throw new Error("[use-convex] ConvexClient is not available on the client.");
   }
   const liveReady = ref(false);
   const liveData = ref();

package/dist/runtime/composables/useConvexR2Upload.d.ts

@@ -0,0 +1,40 @@
+import type { FunctionReference, FunctionReturnType } from 'convex/server';
+/**
+ * Subset of `@convex-dev/r2` `clientApi()` exports needed for client uploads.
+ * Pass `api.example` (or any module that re-exports these two mutations).
+ */
+export type ConvexR2UploadApi = {
+    generateUploadUrl: FunctionReference<'mutation'>;
+    syncMetadata: FunctionReference<'mutation'>;
+};
+export type ConvexR2UploadProgress = {
+    loaded: number;
+    total: number;
+};
+/**
+ * PUT a file to an R2 signed URL (matches `@convex-dev/r2` client upload).
+ */
+export declare function putFileToR2UploadUrl(uploadUrl: string, file: File, onProgress?: (progress: ConvexR2UploadProgress) => void): Promise<void>;
+/**
+ * Vue counterpart of `@convex-dev/r2/react`'s `useUploadFile`.
+ *
+ * Expects the object returned by `r2.clientApi()` (at least
+ * `generateUploadUrl` + `syncMetadata`). Flow:
+ * 1. `generateUploadUrl()` → `{ url, key }`
+ * 2. PUT file bytes to the signed URL
+ * 3. `syncMetadata({ key })`
+ * 4. return `key`
+ *
+ * Does **not** depend on `@convex-dev/r2` at runtime — only on Convex
+ * function references your app exports. Prefer this over built-in
+ * `useConvexFileUpload` for large / resumable-oriented object storage.
+ */
+export declare function useConvexR2Upload(api: ConvexR2UploadApi): {
+    upload: (file: File, options?: {
+        onProgress?: (progress: ConvexR2UploadProgress) => void;
+    }) => Promise<string>;
+    error: import("vue").Ref<Error | null, Error | null>;
+    pending: import("vue").ComputedRef<boolean>;
+    progress: import("vue").ComputedRef<number | null>;
+};
+export type { FunctionReturnType };

package/dist/runtime/composables/useConvexR2Upload.js

@@ -0,0 +1,86 @@
+import { computed, ref } from "vue";
+import { useConvexContext } from "../utils/context.js";
+function parseUploadUrlPayload(value) {
+  if (typeof value === "object" && value !== null && "url" in value && "key" in value && typeof value.url === "string" && typeof value.key === "string" && value.url.length > 0 && value.key.length > 0) {
+    return {
+      url: value.url,
+      key: value.key
+    };
+  }
+  throw new Error("[use-convex] generateUploadUrl must return `{ url, key }` strings.");
+}
+export function putFileToR2UploadUrl(uploadUrl, file, onProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open("PUT", uploadUrl);
+    xhr.setRequestHeader("Content-Type", file.type || "application/octet-stream");
+    xhr.upload.onprogress = (event) => {
+      if (!onProgress) {
+        return;
+      }
+      onProgress({ loaded: event.loaded, total: event.total });
+    };
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        resolve();
+        return;
+      }
+      reject(
+        new Error(`[use-convex] R2 upload failed (${xhr.status} ${xhr.statusText || "error"}).`)
+      );
+    };
+    xhr.onerror = () => {
+      reject(new Error("[use-convex] R2 upload network error."));
+    };
+    xhr.onabort = () => {
+      reject(new Error("[use-convex] R2 upload aborted."));
+    };
+    xhr.send(file);
+  });
+}
+export function useConvexR2Upload(api) {
+  const ctx = useConvexContext();
+  const error = ref(null);
+  const pendingCount = ref(0);
+  const progress = ref(null);
+  const upload = async (file, options) => {
+    if (import.meta.server || !ctx.client) {
+      throw new Error("[use-convex] useConvexR2Upload can only run in the browser.");
+    }
+    if (!(file instanceof File)) {
+      throw new TypeError("[use-convex] useConvexR2Upload expects a File.");
+    }
+    pendingCount.value++;
+    error.value = null;
+    progress.value = null;
+    try {
+      const raw = await ctx.client.mutation(
+        api.generateUploadUrl,
+        {}
+      );
+      const { url, key } = parseUploadUrlPayload(raw);
+      await putFileToR2UploadUrl(url, file, (event) => {
+        if (event.total > 0) {
+          progress.value = event.loaded / event.total;
+        }
+        options?.onProgress?.(event);
+      });
+      progress.value = 1;
+      await ctx.client.mutation(api.syncMetadata, { key });
+      return key;
+    } catch (cause) {
+      const err = cause instanceof Error ? cause : new Error(String(cause));
+      error.value = err;
+      throw err;
+    } finally {
+      pendingCount.value--;
+      progress.value = null;
+    }
+  };
+  return {
+    upload,
+    error,
+    pending: computed(() => pendingCount.value > 0),
+    progress: computed(() => progress.value)
+  };
+}

package/dist/runtime/plugin.client.js

@@ -2,10 +2,8 @@ import { ConvexClient } from "convex/browser";
 import { defineNuxtPlugin, useRuntimeConfig } from "nuxt/app";
 import { useSsrTokenRef } from "./utils/authCookie.js";
 import { createHttpClient } from "./utils/http.js";
-import {
-  convexNuxtKey,
-  createAuthContext
-} from "./utils/context.js";
+import { convexNuxtKey, createAuthContext } from "./utils/context.js";
+import { warnMissingConvexUrl } from "./utils/errors.js";
 export default defineNuxtPlugin({
   name: "convex-nuxt-client",
   setup(nuxtApp) {
@@ -14,9 +12,7 @@ export default defineNuxtPlugin({
     const url = convexConfig?.url;
     if (!url) {
       if (import.meta.dev) {
-        console.warn(
-          "[convex-nuxt] No Convex URL configured. Set convex.url or NUXT_PUBLIC_CONVEX_URL."
-        );
+        warnMissingConvexUrl("client");
       }
       return;
     }

package/dist/runtime/plugin.devtools.client.d.ts

@@ -1,6 +1,19 @@
+import { useConvexConnectionState } from './composables/useConvexConnectionState.js';
+export interface ConvexDevtoolsBridge {
+    connection: ReturnType<typeof useConvexConnectionState>;
+    /** Auth UI / Convex confirmation flags (dev inspection only). */
+    auth: {
+        configured: boolean;
+        isLoading: boolean;
+        isAuthenticated: boolean;
+        isRefreshing: boolean;
+        isConvexAuthenticated: boolean | null;
+        hasSsrToken: boolean;
+    };
+}
 /**
- * Expose connection state on `window.__CONVEX_NUXT__` in development for
- * quick inspection alongside the DevTools iframe tab.
+ * Expose connection + auth snapshot on `window.__CONVEX_NUXT__` in development
+ * for quick inspection alongside the DevTools iframe tab.
  */
 declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

package/dist/runtime/plugin.devtools.client.js

@@ -4,13 +4,27 @@ import { tryUseConvexContext } from "./utils/context.js";
 export default defineNuxtPlugin({
   name: "convex-nuxt-devtools",
   setup() {
-    if (!import.meta.dev || !tryUseConvexContext()) {
+    const ctx = tryUseConvexContext();
+    if (!import.meta.dev || !ctx) {
       return;
     }
     const connection = useConvexConnectionState();
-    if (typeof window !== "undefined") {
-      ;
-      window.__CONVEX_NUXT__ = { connection };
+    if (typeof window === "undefined") {
+      return;
     }
+    const bridge = {
+      connection,
+      get auth() {
+        return {
+          configured: ctx.auth.configured,
+          isLoading: ctx.auth.isLoading.value,
+          isAuthenticated: ctx.auth.isAuthenticated.value,
+          isRefreshing: ctx.auth.isRefreshing.value,
+          isConvexAuthenticated: ctx.auth.isConvexAuthenticated.value,
+          hasSsrToken: Boolean(ctx.ssrToken.value)
+        };
+      }
+    };
+    window.__CONVEX_NUXT__ = bridge;
   }
 });

package/dist/runtime/plugin.server.js

@@ -1,10 +1,8 @@
 import { defineNuxtPlugin, useRuntimeConfig } from "nuxt/app";
 import { useSsrTokenRef } from "./utils/authCookie.js";
 import { createHttpClient } from "./utils/http.js";
-import {
-  convexNuxtKey,
-  createAuthContext
-} from "./utils/context.js";
+import { convexNuxtKey, createAuthContext } from "./utils/context.js";
+import { warnMissingConvexUrl } from "./utils/errors.js";
 export default defineNuxtPlugin({
   name: "convex-nuxt-server",
   setup(nuxtApp) {
@@ -13,9 +11,7 @@ export default defineNuxtPlugin({
     const url = convexConfig?.url;
     if (!url) {
       if (import.meta.dev) {
-        console.warn(
-          "[convex-nuxt] No Convex URL configured. Set convex.url or NUXT_PUBLIC_CONVEX_URL."
-        );
+        warnMissingConvexUrl("server");
       }
       return;
     }

package/dist/runtime/server/api/convex/auth/session.js

@@ -1,26 +1,21 @@
 import { ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
-import {
-  createError,
-  defineEventHandler,
-  readBody
-} from "h3";
+import { createError, defineEventHandler, readBody } from "h3";
 import { useRuntimeConfig } from "nitropack/runtime";
-import {
-  readHttpOnlyJwt,
-  readHttpOnlyRefresh,
-  setAuthCookies
-} from "../../../authCookies.js";
+import { readHttpOnlyJwt, readHttpOnlyRefresh, setAuthCookies } from "../../../authCookies.js";
 import { isHttpOnlyAuth } from "../../../../utils/authStorage.js";
 import { assertSameOrigin } from "../../../sameOrigin.js";
-const authSignIn = makeFunctionReference("auth:signIn");
+import { MISSING_URL_HINT } from "../../../../utils/errors.js";
+const authSignIn = makeFunctionReference(
+  "auth:signIn"
+);
 function convexUrl(event) {
   const config = useRuntimeConfig(event);
   const url = config.public?.convex?.url ?? process.env.NUXT_PUBLIC_CONVEX_URL;
   if (!url) {
     throw createError({
       statusCode: 500,
-      message: "Convex URL is not configured"
+      message: MISSING_URL_HINT
     });
   }
   return url;

package/dist/runtime/server/auth.js

@@ -1,15 +1,7 @@
 import { createError, getCookie } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
 import { resolveAuthCookieName } from "../utils/authStorage.js";
 import { resolveFetchToken } from "../utils/fetchToken.js";
-function readConvexConfig(event) {
-  try {
-    const config = useRuntimeConfig(event);
-    return config.public?.convex;
-  } catch {
-    return void 0;
-  }
-}
+import { readConvexConfig } from "./convexConfig.js";
 export function getConvexToken(event) {
   const cookieName = resolveAuthCookieName(readConvexConfig(event)?.auth);
   if (!cookieName) {

package/dist/runtime/server/authCookies.js

@@ -1,10 +1,4 @@
-import {
-  deleteCookie,
-  getCookie,
-  getRequestHeader,
-  setCookie
-} from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
+import { deleteCookie, getCookie, getRequestHeader, setCookie } from "h3";
 import {
   AUTH_JWT_COOKIE_MAX_AGE,
   isHttpOnlyAuth,
@@ -12,32 +6,18 @@ import {
   resolveAuthPresentCookieName,
   resolveAuthRefreshCookieName
 } from "../utils/authStorage.js";
+import { readConvexConfig } from "./convexConfig.js";
 function readAuthConfig(event) {
-  try {
-    const config = useRuntimeConfig(event);
-    return config.public?.convex?.auth;
-  } catch {
-    return void 0;
-  }
+  return readConvexConfig(event)?.auth;
 }
 function isLocalHost(event) {
   const host = getRequestHeader(event, "host") ?? "";
   return host.startsWith("localhost") || host.startsWith("127.0.0.1") || host.startsWith("[::1]");
 }
-function httpOnlyCookieOptions(event) {
-  const local = isLocalHost(event);
-  return {
-    httpOnly: true,
-    secure: !local,
-    sameSite: "lax",
-    path: "/",
-    maxAge: AUTH_JWT_COOKIE_MAX_AGE
-  };
-}
-function readableCookieOptions(event) {
+function cookieOptions(event, httpOnly) {
   const local = isLocalHost(event);
   return {
-    httpOnly: false,
+    httpOnly,
     secure: !local,
     sameSite: "lax",
     path: "/",
@@ -47,15 +27,13 @@ function readableCookieOptions(event) {
 export function setAuthCookies(event, tokens) {
   const auth = readAuthConfig(event);
   if (!isHttpOnlyAuth(auth)) {
-    throw new Error(
-      "[convex-nuxt] setAuthCookies requires convex.auth.httpOnly: true"
-    );
+    throw new Error("[use-convex] setAuthCookies requires convex.auth.httpOnly: true");
   }
   const jwtName = resolveAuthCookieName(auth);
   const refreshName = resolveAuthRefreshCookieName(auth);
   const presentName = resolveAuthPresentCookieName(auth);
-  const httpOpts = httpOnlyCookieOptions(event);
-  const presentOpts = readableCookieOptions(event);
+  const httpOpts = cookieOptions(event, true);
+  const presentOpts = cookieOptions(event, false);
   if (!tokens.token) {
     deleteCookie(event, jwtName, httpOpts);
     deleteCookie(event, refreshName, httpOpts);

package/dist/runtime/server/convexConfig.d.ts

@@ -0,0 +1,12 @@
+import type { H3Event } from 'h3';
+export interface ConvexPublicConfig {
+    url?: string;
+    auth?: {
+        provider?: string;
+        cookie?: string;
+        httpOnly?: boolean;
+        presentCookie?: string;
+    };
+}
+/** Read `runtimeConfig.public.convex`, or `undefined` outside a Nitro request. */
+export declare function readConvexConfig(event?: H3Event): ConvexPublicConfig | undefined;

package/dist/runtime/server/convexConfig.js

@@ -0,0 +1,9 @@
+import { useRuntimeConfig } from "nitropack/runtime";
+export function readConvexConfig(event) {
+  try {
+    const config = useRuntimeConfig(event);
+    return config.public?.convex;
+  } catch {
+    return void 0;
+  }
+}

package/dist/runtime/server/fetch.d.ts

@@ -1,7 +1,5 @@
 import type { FunctionArgs, FunctionReference, FunctionReturnType } from 'convex/server';
 import type { H3Event } from 'h3';
-import { resolveFetchToken } from '../utils/fetchToken.js';
-export { resolveFetchToken };
 export interface ConvexFetchOptions {
     /**
      * Deployment URL. Defaults to `NUXT_PUBLIC_CONVEX_URL` / runtimeConfig.
@@ -18,9 +16,9 @@ export interface ConvexFetchOptions {
     event?: H3Event;
     skipConvexDeploymentUrlCheck?: boolean;
 }
-/** @internal Exported for unit tests. */
+/** @internal */
 export declare function resolveUrl(options: ConvexFetchOptions): string;
-/** @internal Exported for unit tests. */
+/** @internal */
 export declare function resolveToken(options: ConvexFetchOptions): string | undefined;
 /**
  * One-shot query via ConvexHttpClient. Use in Nitro routes / server middleware.

package/dist/runtime/server/fetch.js

@@ -1,17 +1,9 @@
 import { getCookie } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
 import { createHttpClient } from "../utils/http.js";
 import { resolveAuthCookieName } from "../utils/authStorage.js";
 import { resolveFetchToken } from "../utils/fetchToken.js";
-export { resolveFetchToken };
-function readConvexConfig(event) {
-  try {
-    const config = useRuntimeConfig(event);
-    return config.public?.convex;
-  } catch {
-    return void 0;
-  }
-}
+import { missingConvexUrlError } from "../utils/errors.js";
+import { readConvexConfig } from "./convexConfig.js";
 export function resolveUrl(options) {
   if (options.url) {
     return options.url;
@@ -24,9 +16,7 @@ export function resolveUrl(options) {
   if (fromEnv) {
     return fromEnv;
   }
-  throw new Error(
-    "[convex-nuxt] No Convex URL. Pass { url } or set NUXT_PUBLIC_CONVEX_URL."
-  );
+  throw missingConvexUrlError("fetchQuery/Mutation/Action");
 }
 export function resolveToken(options) {
   if (options.token !== void 0) {

package/dist/runtime/server/routes/__convex_devtools.get.d.ts

@@ -1,6 +1,10 @@
 /**
- * Minimal DevTools iframe — shows public Convex runtime config.
- * Connection state is available in-app via `useConvexConnectionState()`.
+ * DevTools iframe — embeds Convex dashboard (cloud) + public config tips.
+ * Live auth/connection: `window.__CONVEX_NUXT__` (devtools client plugin).
+ *
+ * Auto-login uses CONVEX_DEPLOY_KEY via postMessage to dashboard-embedded.
+ * Without a key, the embed shows Convex's credential form; Open dashboard
+ * still deep-links to dashboard.convex.dev (existing session).
  */
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, string>;
 export default _default;