nuxt-convex-module 0.13.0 → 0.14.0

package/dist/devtools-client/index.html

@@ -1 +1 @@
-<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><script type="importmap">{"imports":{"#entry":"/__nuxt-convex-module/_nuxt/CtC_CmOY.js"}}</script><link rel="stylesheet" href="/__nuxt-convex-module/_nuxt/entry.jOWrhpYd.css" crossorigin><link rel="modulepreload" as="script" crossorigin href="/__nuxt-convex-module/_nuxt/CtC_CmOY.js"><script type="module" src="/__nuxt-convex-module/_nuxt/CtC_CmOY.js" crossorigin></script><link rel="prefetch" as="script" crossorigin href="/__nuxt-convex-module/_nuxt/C-J9qZjr.js"></head><body><div id="__nuxt"></div><div id="teleports"></div><script>window.__NUXT__={};window.__NUXT__.config={public:{},app:{baseURL:"/__nuxt-convex-module",buildId:"ad777e0e-9095-4e0e-9b9b-8010fe4e34c6",buildAssetsDir:"/_nuxt/",cdnURL:""}}</script><script type="application/json" data-nuxt-data="nuxt-app" data-ssr="false" id="__NUXT_DATA__">[{"prerenderedAt":1,"serverRendered":2},1794085598149,false]</script></body></html>
+<!DOCTYPE html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><script type="importmap">{"imports":{"#entry":"/__nuxt-convex-module/_nuxt/CtC_CmOY.js"}}</script><link rel="stylesheet" href="/__nuxt-convex-module/_nuxt/entry.jOWrhpYd.css" crossorigin><link rel="modulepreload" as="script" crossorigin href="/__nuxt-convex-module/_nuxt/CtC_CmOY.js"><script type="module" src="/__nuxt-convex-module/_nuxt/CtC_CmOY.js" crossorigin></script><link rel="prefetch" as="script" crossorigin href="/__nuxt-convex-module/_nuxt/C-J9qZjr.js"></head><body><div id="__nuxt"></div><div id="teleports"></div><script>window.__NUXT__={};window.__NUXT__.config={public:{},app:{baseURL:"/__nuxt-convex-module",buildId:"168fd639-55a2-4ae2-9c90-a285b0720204",buildAssetsDir:"/_nuxt/",cdnURL:""}}</script><script type="application/json" data-nuxt-data="nuxt-app" data-ssr="false" id="__NUXT_DATA__">[{"prerenderedAt":1,"serverRendered":2},1794180177669,false]</script></body></html>

package/dist/module.d.mts

@@ -2,6 +2,8 @@ import * as _nuxt_schema from '@nuxt/schema';
 
 /** The `convex.autoImports` option: every name, every name prefixed with `Convex`, or none. */
 type AutoImports = boolean | 'prefixed';
+/** The `convex.exclude` option: registered names to skip, each exact or a pattern. */
+type ExcludedNames = ReadonlyArray<string | RegExp>;
 
 /**
  * Configuration for the opt-in Better Auth integration.
@@ -108,6 +110,20 @@ interface ModuleOptions {
      * the subpath exports. `false` auto-imports nothing.
      */
     autoImports?: AutoImports;
+    /**
+     * Names to leave unregistered, matched against the name the app would see
+     * (after `prefixed` renames it): app auto-imports, Nitro auto-imports,
+     * components and the `convex-auth` route middleware. A string matches one
+     * name exactly, a `RegExp` every name it matches. Everything stays
+     * importable from the subpath exports. Meant for a module that builds on
+     * this one and registers names of its own for the same things.
+     *
+     * @example
+     * ```ts
+     * convex: { exclude: [/^useConvex/, 'ConvexImage', 'convex-auth'] }
+     * ```
+     */
+    exclude?: ExcludedNames;
     /**
      * Convex panel in Nuxt DevTools (dev only): connection state, live query
      * subscriptions, auth state, and client logs. Enabled by default whenever
@@ -134,6 +150,8 @@ declare module '@nuxt/schema' {
             crossDomainCallbackRoute: string;
             loginPath: string;
             authRoute: string;
+            /** Whether the browser may hold the Better Auth client back (PARITY D-18): only where the registration transform runs, on Vite. */
+            deferAuthClient: boolean;
         };
     }
 }

package/dist/module.json

@@ -5,7 +5,7 @@
   "compatibility": {
     "nuxt": ">=4.6.0"
   },
-  "version": "0.13.0",
+  "version": "0.14.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,7 +1,7 @@
-import { useLogger, defineNuxtModule, createResolver, addPlugin, hasNuxtModule, addNitroPlugin, addTypeTemplate, addImports, addServerImports, addComponent, addServerHandler, extendRouteRules, addRouteMiddleware } from '@nuxt/kit';
-import { dirname, join, isAbsolute, basename } from 'node:path';
+import { useLogger, addVitePlugin, resolvePath, defineNuxtModule, createResolver, addPlugin, hasNuxtModule, addNitroPlugin, addTypeTemplate, addImports, addServerImports, addComponent, addServerHandler, extendRouteRules, addRouteMiddleware } from '@nuxt/kit';
+import path, { dirname, join, isAbsolute, basename } from 'node:path';
 import { detectAgent } from 'std-env';
-import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, statSync, realpathSync, writeFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { parseEnv } from 'node:util';
 
@@ -206,6 +206,71 @@ function getConvexAliases(rootDir) {
   };
 }
 
+const SCRIPT_EXTENSION = /\.(?:[cm]?[jt]sx?|vue)$/;
+const posix = (file) => file.replaceAll("\\", "/");
+function sameModule(file, target) {
+  if (SCRIPT_EXTENSION.test(target)) return posix(file) === posix(target);
+  return posix(file).replace(SCRIPT_EXTENSION, "") === posix(target);
+}
+function manifestKeyMatches(key, root, target, paths = path) {
+  return sameModule(key, paths.relative(root, target));
+}
+function real(file) {
+  try {
+    return realpathSync(file);
+  } catch {
+    return file;
+  }
+}
+function authClientFiles(nuxt) {
+  let files;
+  return () => files ??= (async () => {
+    const target = nuxt.options.alias["#convex/auth-client"];
+    if (!target) return [];
+    const resolved = await resolvePath(target, { fallbackToOriginal: true });
+    return [...new Set(resolved === target ? [target, real(target)] : [resolved, real(resolved)])];
+  })();
+}
+function authClientRegistration(file, loader) {
+  return [
+    "",
+    "// nuxt-convex-module (PARITY D-18): tell the loader this client has evaluated.",
+    `import { registerEvaluatedAuthClient as __convexRegisterAuthClient } from ${JSON.stringify(loader)}`,
+    `import * as __convexAuthClientModule from ${JSON.stringify(`./${basename(file)}`)}`,
+    "__convexRegisterAuthClient(__convexAuthClientModule.authClient)",
+    ""
+  ].join("\n");
+}
+function registerAuthClientOnEvaluation(resolver, nuxt) {
+  const loader = resolver.resolve("./runtime/better-auth/vue/auth-client-loader");
+  const files = authClientFiles(nuxt);
+  addVitePlugin({
+    name: "nuxt-convex-module:auth-client-registration",
+    async transform(code, id, transformOptions) {
+      if (transformOptions?.ssr) return;
+      const file = id.split("?")[0];
+      if (!(await files()).some((target) => sameModule(file, target))) return;
+      return { code: code + authClientRegistration(file, loader), map: null };
+    }
+  }, { server: false });
+}
+function keepAuthClientOffPrefetch(nuxt) {
+  const files = authClientFiles(nuxt);
+  nuxt.hook("build:manifest", async (manifest) => {
+    const targets = await files();
+    if (targets.length === 0) return;
+    const root = nuxt.options.vite?.root ?? nuxt.options.srcDir;
+    const roots = [.../* @__PURE__ */ new Set([root, real(root)])];
+    const isAuthClient = (key) => roots.some((base) => targets.some((target) => manifestKeyMatches(manifest[key]?.src ?? key, base, target)));
+    const keys = new Set(Object.keys(manifest).filter(isAuthClient));
+    if (keys.size === 0) return;
+    for (const chunk of Object.values(manifest)) {
+      chunk.dynamicImports &&= chunk.dynamicImports.filter((key) => !keys.has(key));
+    }
+    for (const key of keys) manifest[key].prefetch = false;
+  });
+}
+
 function watchConvexCodegen(nuxt) {
   if (!nuxt.options.dev) return;
   const generatedDir = join(nuxt.options.rootDir, resolveFunctionsDir(nuxt.options.rootDir), "_generated");
@@ -253,6 +318,17 @@ function autoImportedAs(name, mode, registered) {
   const prefixed = prefixedName(name);
   return prefixed !== name && registered.includes(prefixed) ? void 0 : prefixed;
 }
+function isExcluded(name, exclude) {
+  return exclude.some((rule) => {
+    if (typeof rule === "string") return rule === name;
+    rule.lastIndex = 0;
+    return rule.test(name);
+  });
+}
+function registeredAs(name, policy, registered) {
+  const as = autoImportedAs(name, policy.autoImports, registered);
+  return as === void 0 || isExcluded(as, policy.exclude) ? void 0 : as;
+}
 const vue = (file) => `runtime/vue/${file}`;
 const composable = (file) => vue(`composables/${file}`);
 const asyncQuery = "runtime/nuxt/composables/use-async-query";
@@ -300,6 +376,7 @@ const APP_IMPORTS = {
   ],
   betterAuth: [
     { name: "useBetterAuth", from: "runtime/better-auth/vue/use-better-auth" },
+    { name: "loadAuthClient", from: "runtime/better-auth/vue/auth-client-loader" },
     { name: "usePreloadedAuthQuery", from: "runtime/better-auth/vue/hydration" },
     { name: "resolveAuthRedirect", from: "runtime/better-auth/vue/redirect" }
   ],
@@ -403,13 +480,16 @@ const module$1 = defineNuxtModule({
     for (const message of diagnostics.warnings) logger.warn(message);
     nuxt.options.runtimeConfig.public.convex.loginPath = diagnostics.loginPath;
     nuxt.options.runtimeConfig.public.convex.authRoute = diagnostics.authRoute;
+    nuxt.options.runtimeConfig.public.convex.deferAuthClient = nuxt.options.builder === "@nuxt/vite-builder";
     registerAuthClientAlias(resolver, nuxt, options);
+    keepAuthClientOffPrefetch(nuxt);
+    registerAuthClientOnEvaluation(resolver, nuxt);
     registerConvexAliases(nuxt);
     registerConvexTypeFallback(nuxt);
-    const autoImports = options.autoImports ?? true;
-    registerVueComposables(resolver, autoImports);
-    registerAuthComponents(resolver, autoImports);
-    const integrations = registerIntegrations(resolver, nuxt, options, autoImports, diagnostics.authRoute);
+    const policy = { autoImports: options.autoImports ?? true, exclude: options.exclude ?? [] };
+    registerVueComposables(resolver, policy);
+    registerAuthComponents(resolver, policy);
+    const integrations = registerIntegrations(resolver, nuxt, options, policy, diagnostics.authRoute);
     watchConvexCodegen(nuxt);
     if (nuxt.options.dev && options.devtools !== false && isDevtoolsUiEnabled(nuxt)) {
       const { setupDevtools } = await import('./chunks/index.mjs');
@@ -444,7 +524,7 @@ function isDevtoolsUiEnabled(nuxt) {
   const devtools = nuxt.options.devtools;
   return typeof devtools === "boolean" ? devtools : devtools?.enabled !== false;
 }
-function registerIntegrations(resolver, nuxt, options, autoImports, authRoute) {
+function registerIntegrations(resolver, nuxt, options, policy, authRoute) {
   const report = (key, pkg, state) => {
     if (state.missingPackage) {
       logger.error(`\`convex.${key}\` is enabled but \`${pkg}\` is not installed. Run \`npm install ${pkg}\` or remove the option.`);
@@ -455,21 +535,21 @@ function registerIntegrations(resolver, nuxt, options, autoImports, authRoute) {
   const resolve = (key, pkg) => report(key, pkg, resolveIntegrationState(options[key], isPackageInstalled(pkg, rootDir), isDeclaredDependency(pkg, rootDir)));
   const betterAuth = resolve("betterAuth", "@convex-dev/better-auth");
   if (betterAuth) {
-    registerBetterAuth(resolver, authRoute, autoImports);
+    registerBetterAuth(resolver, authRoute, policy);
   } else {
     registerBaseConvexClient(resolver);
   }
   const clerk = resolve("clerk", "@clerk/vue");
   if (clerk) {
-    registerClerk(resolver, autoImports);
+    registerClerk(resolver, policy);
   }
   const auth0 = resolve("auth0", "@auth0/auth0-vue");
   if (auth0) {
-    registerAuth0(resolver, autoImports);
+    registerAuth0(resolver, policy);
   }
   const polar = resolve("polar", "@convex-dev/polar");
   if (polar) {
-    registerPolarComponents(resolver, autoImports);
+    registerPolarComponents(resolver, policy);
   }
   const security = report("security", "nuxt-security", resolveSecurityState(nuxt, options.security));
   if (security) {
@@ -577,15 +657,15 @@ function registerConvexTypeFallback(nuxt) {
     dependsOn: (change) => change.path.replace(/\\/g, "/").includes("_generated/api")
   }, { nuxt: true, nitro: true });
 }
-function registerVueComposables(resolver, autoImports) {
-  registerIntegrationImports(resolver, "core", autoImports);
+function registerVueComposables(resolver, policy) {
+  registerIntegrationImports(resolver, "core", policy);
 }
-function registerAuthComponents(resolver, autoImports) {
-  registerComponents(resolver, "core", autoImports);
+function registerAuthComponents(resolver, policy) {
+  registerComponents(resolver, "core", policy);
 }
-function registerIntegrationImports(resolver, integration, autoImports) {
+function registerIntegrationImports(resolver, integration, policy) {
   const kept = (entries) => entries.flatMap((entry) => {
-    const as = autoImportedAs(entry.name, autoImports, entries.map((e) => e.name));
+    const as = registeredAs(entry.name, policy, entries.map((e) => e.name));
     return as ? [{ ...entry, as, from: resolver.resolve(`./${entry.from}`) }] : [];
   });
   const app = kept(APP_IMPORTS[integration]);
@@ -593,10 +673,10 @@ function registerIntegrationImports(resolver, integration, autoImports) {
   if (app.length > 0) addImports(app);
   if (server.length > 0) addServerImports(server);
 }
-function registerComponents(resolver, integration, autoImports) {
+function registerComponents(resolver, integration, policy) {
   const entries = APP_COMPONENTS[integration];
   for (const { name, from } of entries) {
-    const as = autoImportedAs(name, autoImports, entries.map((e) => e.name));
+    const as = registeredAs(name, policy, entries.map((e) => e.name));
     if (as) addComponent({ name: as, filePath: resolver.resolve(`./${from}`), export: name });
   }
 }
@@ -604,11 +684,13 @@ const AUTH_PROXY_SECURITY_RULES = {
   xssValidator: false,
   allowedMethodsRestricter: { methods: ["GET", "HEAD", "POST", "OPTIONS"] }
 };
-function registerBetterAuth(resolver, authRoute, autoImports) {
+function registerBetterAuth(resolver, authRoute, policy) {
   addPlugin(resolver.resolve("./runtime/better-auth/vue/plugin.client"));
   addPlugin(resolver.resolve("./runtime/better-auth/vue/plugin.server"));
-  registerIntegrationImports(resolver, "betterAuth", autoImports);
-  registerComponents(resolver, "betterAuth", autoImports);
+  const noSessionVary = resolver.resolve("./runtime/better-auth/nuxt/no-session-vary");
+  addNitroPlugin({ nitro2: noSessionVary, nitro3: noSessionVary });
+  registerIntegrationImports(resolver, "betterAuth", policy);
+  registerComponents(resolver, "betterAuth", policy);
   addServerHandler({
     route: `${authRoute}/**`,
     handler: { nuxt: resolver.resolve("./runtime/better-auth/nuxt/proxy") }
@@ -618,25 +700,27 @@ function registerBetterAuth(resolver, authRoute, autoImports) {
     prerender: false,
     security: AUTH_PROXY_SECURITY_RULES
   });
-  addRouteMiddleware({
-    name: "convex-auth",
-    path: resolver.resolve("./runtime/better-auth/nuxt/middleware"),
-    global: false
-  });
+  if (!isExcluded("convex-auth", policy.exclude)) {
+    addRouteMiddleware({
+      name: "convex-auth",
+      path: resolver.resolve("./runtime/better-auth/nuxt/middleware"),
+      global: false
+    });
+  }
 }
 function registerBaseConvexClient(resolver) {
   addPlugin(resolver.resolve("./runtime/vue/plugin"));
 }
-function registerClerk(resolver, autoImports) {
-  registerIntegrationImports(resolver, "clerk", autoImports);
-  registerComponents(resolver, "clerk", autoImports);
+function registerClerk(resolver, policy) {
+  registerIntegrationImports(resolver, "clerk", policy);
+  registerComponents(resolver, "clerk", policy);
 }
-function registerAuth0(resolver, autoImports) {
-  registerIntegrationImports(resolver, "auth0", autoImports);
-  registerComponents(resolver, "auth0", autoImports);
+function registerAuth0(resolver, policy) {
+  registerIntegrationImports(resolver, "auth0", policy);
+  registerComponents(resolver, "auth0", policy);
 }
-function registerPolarComponents(resolver, autoImports) {
-  registerComponents(resolver, "polar", autoImports);
+function registerPolarComponents(resolver, policy) {
+  registerComponents(resolver, "polar", policy);
 }
 
 export { module$1 as default };

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

@@ -1,6 +1,7 @@
 import { defineNuxtRouteMiddleware, navigateTo, useRuntimeConfig } from "#app";
 import { watch } from "vue";
-import { useBetterAuth } from "../vue/use-better-auth.js";
+import { clientSessionSettled, useBetterAuth } from "../vue/use-better-auth.js";
+import { loadedAuthClient } from "../vue/auth-client-loader.js";
 import { loginTarget, serverGuard } from "./server-guard.js";
 function waitForSession(isPending) {
   return new Promise((resolve) => {
@@ -21,7 +22,12 @@ export default defineNuxtRouteMiddleware(async (to) => {
   if (import.meta.server) {
     return serverGuard(to, loginPath);
   }
-  const { session } = useBetterAuth();
+  const { session, isAuthenticated } = useBetterAuth();
+  await clientSessionSettled();
+  if (!loadedAuthClient()) {
+    if (!isAuthenticated.value && to.path !== loginPath) return navigateTo(loginTarget(to, loginPath));
+    return;
+  }
   if (session.value.isPending) {
     await waitForSession(() => session.value.isPending);
   }

package/dist/runtime/better-auth/nuxt/no-session-vary.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The slice of a response event this plugin reads and writes: Nitro 2's node
+ * response, or Nitro 3's web headers. Typed locally, so the published types
+ * don't depend on how the app resolves `nitropack`.
+ */
+export interface NoSessionResponseEvent {
+    context: Record<string, unknown>;
+    node?: {
+        res?: {
+            getHeader?: (name: string) => unknown;
+            setHeader?: (name: string, value: string) => unknown;
+        };
+    };
+    res?: {
+        headers?: {
+            get: (name: string) => string | null;
+            set: (name: string, value: string) => void;
+        };
+    };
+}
+/** The Nitro app hook this plugin listens on. */
+export interface NoSessionNitroApp {
+    hooks: {
+        hook: (name: 'beforeResponse', fn: (event: NoSessionResponseEvent) => void) => unknown;
+    };
+}
+/** `vary` with `Cookie` in it, keeping what it named already. */
+export declare function withCookieVary(vary: unknown): string;
+/**
+ * Nitro plugin: a response whose payload says the server saw no session, made
+ * cacheable after the page rendered (a `render:response` hook, a header set
+ * once the payload was written), varies on `Cookie`. The payload can no
+ * longer change by then; varying keeps a shared cache from handing that
+ * cookie-less render to a visitor whose request carries a session cookie.
+ * Runs on `beforeResponse`, after every `render:response` hook and the
+ * headers they set.
+ */
+export default function noSessionVaryPlugin(nitroApp: NoSessionNitroApp): void;

package/dist/runtime/better-auth/nuxt/no-session-vary.js

@@ -0,0 +1,21 @@
+import { CACHING_HEADERS, isSharedRender, NO_SESSION_CONTEXT_KEY } from "./shared-render.js";
+function readHeader(event, name) {
+  return event.node?.res?.getHeader?.(name) ?? event.res?.headers?.get(name) ?? void 0;
+}
+function writeHeader(event, name, value) {
+  if (event.node?.res?.setHeader) event.node.res.setHeader(name, value);
+  else event.res?.headers?.set(name, value);
+}
+export function withCookieVary(vary) {
+  const names = (Array.isArray(vary) ? vary.join(",") : typeof vary === "string" ? vary : "").split(",").map((name) => name.trim()).filter(Boolean);
+  if (names.includes("*") || names.some((name) => name.toLowerCase() === "cookie")) return names.join(", ");
+  return [...names, "Cookie"].join(", ");
+}
+export default function noSessionVaryPlugin(nitroApp) {
+  nitroApp.hooks.hook("beforeResponse", (event) => {
+    if (event.context[NO_SESSION_CONTEXT_KEY] !== true) return;
+    const headers = Object.fromEntries(CACHING_HEADERS.map((name) => [name, readHeader(event, name)]));
+    if (!isSharedRender({ headers })) return;
+    writeHeader(event, "vary", withCookieVary(readHeader(event, "vary")));
+  });
+}

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

@@ -1,6 +1,7 @@
 import { getToken } from "@convex-dev/better-auth/utils";
 import { getConvexRuntimeConfig } from "../../nuxt/config.js";
 import { fetchAction, fetchMutation, fetchQuery, preloadQuery } from "../../nuxt/index.js";
+import { withoutFunctionName } from "../../nuxt/function-name.js";
 const parseConvexSiteUrl = (url) => {
   if (!url) {
     throw new Error(
@@ -107,7 +108,7 @@ export function convexAuth(event, opts) {
     try {
       return await fn(token?.token);
     } catch (error) {
-      if (!opts?.jwtCache?.enabled || token.isFresh || !opts.jwtCache.isAuthError(error)) {
+      if (!opts?.jwtCache?.enabled || token.isFresh || !withoutFunctionName(error, opts.jwtCache.isAuthError.bind(opts.jwtCache))) {
         throw error;
       }
       const newToken = await cachedGetToken({ forceRefresh: true });

package/dist/runtime/better-auth/nuxt/shared-render.d.ts

@@ -0,0 +1,9 @@
+/** The parts of a request event `isSharedRender` reads. */
+export interface RenderContext {
+    /** Nitro's matched route rules (`event.context._nitro.routeRules`), `swr`/`isr` normalised into `cache`. */
+    routeRules?: Record<string, unknown>;
+    /** Set by Nitro's cached handler on the render it caches (`event.context.cache`). */
+    cache?: unknown;
+    /** The response's caching headers as the render sees them, by lower-case name. */
+    headers?: Record<string, unknown>;
+}

package/dist/runtime/better-auth/nuxt/shared-render.js

@@ -0,0 +1,17 @@
+export const NO_SESSION_CONTEXT_KEY = "convexNoSession";
+export const CACHING_HEADERS = ["cache-control", "cdn-cache-control", "surrogate-control"];
+function headerText(value) {
+  if (Array.isArray(value)) return value.join(",");
+  return typeof value === "string" || typeof value === "number" ? String(value) : "";
+}
+function storesForOthers(name, value) {
+  const directives = value.toLowerCase().split(",").map((directive) => directive.trim().split("=")[0]).filter(Boolean);
+  if (directives.length === 0 || directives.includes("private") || directives.includes("no-store")) return false;
+  if (name !== "cache-control") return true;
+  return directives.includes("public") || directives.includes("s-maxage") || directives.includes("max-age");
+}
+export function isSharedRender({ routeRules = {}, cache, headers = {} }) {
+  if (cache || routeRules.cache || routeRules.swr || routeRules.isr || routeRules.prerender || routeRules.payload) return true;
+  const ruleHeaders = Object.fromEntries(Object.entries(routeRules.headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]));
+  return CACHING_HEADERS.some((name) => storesForOthers(name, headerText(headers[name])) || storesForOthers(name, headerText(ruleHeaders[name])));
+}

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

@@ -0,0 +1,17 @@
+import type { AuthClient } from '#convex/auth-client';
+/**
+ * The app's Better Auth client (`#convex/auth-client`), loading it on the
+ * first call. Every call resolves to the same instance, the one a static
+ * `import { authClient } from 'nuxt-convex-module/better-auth/client'` holds.
+ *
+ * @example
+ * ```ts
+ * async function signOut() {
+ *   const client = await loadAuthClient()
+ *   await client.signOut()
+ * }
+ * ```
+ *
+ * @public
+ */
+export declare function loadAuthClient(): Promise<AuthClient>;

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

@@ -0,0 +1,186 @@
+import { getCurrentScope, onScopeDispose, shallowRef, watch } from "vue";
+let loaded;
+let loading;
+let deferred = false;
+const waiting = /* @__PURE__ */ new Set();
+let evaluated;
+let stopSignal;
+export function loadAuthClient() {
+  if (evaluated) registerAuthClient(evaluated);
+  loading ??= import("#convex/auth-client").then(
+    ({ authClient }) => {
+      registerAuthClient(authClient);
+      return authClient;
+    },
+    (error) => {
+      loading = void 0;
+      throw error;
+    }
+  );
+  return loading;
+}
+export function registerEvaluatedAuthClient(client) {
+  if (loaded || evaluated === client) return;
+  if (!deferred) return registerAuthClient(client);
+  evaluated = client;
+  const signal = client.$store?.atoms?.$sessionSignal;
+  stopSignal = signal?.listen?.(() => registerAuthClient(client));
+}
+export function registerAuthClient(client) {
+  if (loaded) return;
+  stopSignal?.();
+  stopSignal = void 0;
+  evaluated = void 0;
+  loaded = client;
+  loading ??= Promise.resolve(client);
+  const listeners = [...waiting];
+  waiting.clear();
+  for (const listener of listeners) {
+    try {
+      listener(client);
+    } catch (error) {
+      report(error);
+    }
+  }
+}
+function report(error) {
+  if (typeof globalThis.reportError === "function") globalThis.reportError(error);
+  else queueMicrotask(() => {
+    throw error;
+  });
+}
+export function loadedAuthClient() {
+  return loaded;
+}
+export function onAuthClient(listener) {
+  if (loaded) {
+    listener(loaded);
+    return () => {
+    };
+  }
+  waiting.add(listener);
+  return () => waiting.delete(listener);
+}
+export function deferAuthClient() {
+  if (deferred || loaded) return;
+  deferred = true;
+  const onVisible = () => {
+    if (document.visibilityState !== "visible") return;
+    void loadAuthClient().then(() => document.removeEventListener("visibilitychange", onVisible), () => {
+    });
+  };
+  document.addEventListener("visibilitychange", onVisible);
+}
+export function retryAuthClientLoad() {
+  if (loaded || typeof window === "undefined") return;
+  const retry = () => {
+    if (document.visibilityState !== "visible") return;
+    void loadAuthClient().then(() => {
+      window.removeEventListener("online", retry);
+      document.removeEventListener("visibilitychange", retry);
+    }, () => {
+    });
+  };
+  window.addEventListener("online", retry);
+  document.addEventListener("visibilitychange", retry);
+}
+export function isAuthClientDeferred() {
+  return deferred && !loaded;
+}
+function reach(client, path) {
+  let owner;
+  let value = client;
+  for (const key of path) {
+    owner = value;
+    value = value[key];
+  }
+  return { owner, value };
+}
+function call(client, path, args) {
+  const { owner, value } = reach(client, path);
+  return Reflect.apply(value, owner, args);
+}
+const HOOK = /^use[A-Z]/;
+function pendingSubscription(path, args) {
+  let unsubscribe;
+  const stopWaiting = onAuthClient((client) => {
+    unsubscribe = call(client, path, args);
+  });
+  void loadAuthClient().catch(() => {
+  });
+  return () => {
+    stopWaiting();
+    unsubscribe?.();
+  };
+}
+function pendingHook(path, args) {
+  const scope = getCurrentScope();
+  const refetch = async (...refetchArgs) => {
+    await loadAuthClient();
+    const next = state.value.refetch;
+    if (next === refetch) return;
+    return next(...refetchArgs);
+  };
+  const state = shallowRef({
+    data: null,
+    error: null,
+    isPending: true,
+    isRefetching: false,
+    refetch
+  });
+  if (import.meta.server) return state;
+  const stopWaiting = onAuthClient((client) => {
+    const follow = () => watch(call(client, path, args), (value) => {
+      state.value = value;
+    }, { immediate: true, flush: "sync" });
+    if (!scope) follow();
+    else if (scope.active) scope.run(follow);
+  });
+  if (scope) onScopeDispose(stopWaiting);
+  void loadAuthClient().catch(() => loadAuthClient()).catch((error) => {
+    if (!loaded) state.value = { ...state.value, isPending: false, error };
+  });
+  return state;
+}
+const withReceivers = /* @__PURE__ */ new WeakMap();
+function withReceiver(member, owner) {
+  if (typeof member !== "function" || typeof owner !== "object" || owner === null) return member;
+  let byMethod = withReceivers.get(owner);
+  if (!byMethod) withReceivers.set(owner, byMethod = /* @__PURE__ */ new WeakMap());
+  let wrapped = byMethod.get(member);
+  if (!wrapped) {
+    wrapped = new Proxy(member, {
+      apply: (fn, _this, args) => Reflect.apply(fn, owner, args)
+    });
+    byMethod.set(member, wrapped);
+  }
+  return wrapped;
+}
+function lazyPath(path) {
+  return new Proxy(() => {
+  }, {
+    get(_target, key) {
+      if (loaded) {
+        const owner = reach(loaded, path).value;
+        return withReceiver(owner[key], owner);
+      }
+      if (key === "then") return void 0;
+      return lazyPath([...path, key]);
+    },
+    apply(_target, _this, args) {
+      if (loaded) return call(loaded, path, args);
+      const name = path.at(-1);
+      if (typeof name === "string" && HOOK.test(name) && typeof args[0] !== "function") return pendingHook(path, args);
+      if (name === "subscribe" || name === "listen") return pendingSubscription(path, args);
+      return loadAuthClient().then((client) => call(client, path, args));
+    }
+  });
+}
+export const lazyAuthClient = lazyPath([]);
+export function __resetAuthClientLoaderForTests() {
+  deferred = false;
+  stopSignal?.();
+  stopSignal = void 0;
+  evaluated = void 0;
+  waiting.clear();
+}

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

@@ -1,4 +1,4 @@
-import { authClient } from '#convex/auth-client';
+import type { AuthClient } from '#convex/auth-client';
 /**
  * An {@link AuthClient} that also includes the `crossDomainClient()` plugin.
  *
@@ -8,7 +8,7 @@ import { authClient } from '#convex/auth-client';
  *
  * @public
  */
-export type AuthClientWithCrossDomain = typeof authClient & {
+export type AuthClientWithCrossDomain = AuthClient & {
     updateSession: () => void;
     crossDomain?: {
         oneTimeToken: {