nuxt-convex-module 0.12.3 → 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/COXexnyN.js"}}</script><link rel="stylesheet" href="/__nuxt-convex-module/_nuxt/entry.DsZySRVW.css" crossorigin><link rel="modulepreload" as="script" crossorigin href="/__nuxt-convex-module/_nuxt/COXexnyN.js"><script type="module" src="/__nuxt-convex-module/_nuxt/COXexnyN.js" crossorigin></script><link rel="prefetch" as="script" crossorigin href="/__nuxt-convex-module/_nuxt/BPtiIkWa.js"></head><body><div id="__nuxt"></div><div id="teleports"></div><script>window.__NUXT__={};window.__NUXT__.config={public:{},app:{baseURL:"/__nuxt-convex-module",buildId:"bfa6df52-caf6-46de-a611-bdf9d975bd3f",buildAssetsDir:"/_nuxt/",cdnURL:""}}</script><script type="application/json" data-nuxt-data="nuxt-app" data-ssr="false" id="__NUXT_DATA__">[{"prerenderedAt":1,"serverRendered":2},1793468157767,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.12.3",
+  "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';
 
@@ -95,7 +95,7 @@ function integrationWarnings(flags, isInstalled) {
   }
   if (flags.polar && !isInstalled("@polar-sh/checkout")) {
     warnings.push(
-      "`@convex-dev/polar` is installed but its peer `@polar-sh/checkout` is not \u2014 `<CheckoutLink>` imports it and the build fails the moment the component is used. Run `npm install @polar-sh/checkout@~0.4.0`."
+      "`@convex-dev/polar` is installed but its peer `@polar-sh/checkout` is not \u2014 `<CheckoutLink>` imports it and the build fails the moment the component is used. Run `npm install @polar-sh/checkout@~0.6.0`."
     );
   }
   return warnings;
@@ -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" }
   ],
@@ -383,7 +460,7 @@ const module$1 = defineNuxtModule({
   // with no extra entry on the consumer's side. The Convex-aware CSP is applied
   // at runtime (see `registerSecurity`), so module order is irrelevant. Nothing
   // is declared otherwise: kit fails the build resolving an absent package.
-  moduleDependencies: (nuxt) => resolveSecurityState(nuxt, readSecurityOption(nuxt)).enabled ? { "nuxt-security": {} } : {},
+  moduleDependencies: (nuxt) => resolveSecurityState(nuxt, readSecurityOption(nuxt)).enabled ? { "nuxt-security": nuxt.options.dev ? { defaults: DEV_SECURITY_DEFAULTS } : {} } : {},
   async setup(options, nuxt) {
     const resolver = createResolver(import.meta.url);
     nuxt.options.build.transpile.push(resolver.resolve("./runtime"));
@@ -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) {
@@ -486,6 +566,13 @@ function registerIntegrations(resolver, nuxt, options, autoImports, authRoute) {
   }
   return flags;
 }
+const DEV_SECURITY_DEFAULTS = {
+  rateLimiter: false,
+  headers: {
+    contentSecurityPolicy: { "upgrade-insecure-requests": false },
+    strictTransportSecurity: false
+  }
+};
 function readSecurityOption(nuxt) {
   const opts = nuxt.options;
   return opts.convex?.security;
@@ -570,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]);
@@ -586,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 });
   }
 }
@@ -597,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") }
@@ -611,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(
@@ -44,6 +45,8 @@ const handler = async (request, siteUrl) => {
   headers.delete("connection");
   headers.set("accept-encoding", "application/json");
   headers.set("host", new URL(siteUrl).host);
+  headers.delete("x-forwarded-host");
+  headers.delete("x-forwarded-proto");
   headers.set("x-better-auth-forwarded-host", requestUrl.host);
   headers.set("x-better-auth-forwarded-proto", requestUrl.protocol.replace(/:$/, ""));
   const init = {
@@ -105,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>;