@lupinum/better-convex-nuxt 0.8.0-beta.40

package/dist/runtime/auth/integrated-client.js

@@ -0,0 +1,132 @@
+const HIDDEN_ROOT_KEYS = /* @__PURE__ */ new Set([
+  "$fetch",
+  "$store",
+  "hydrateSession",
+  // Installed only for the module-owned token exchange. It is intentionally
+  // absent from the inferred consumer type and must also be absent at runtime.
+  "convex"
+]);
+const NON_THENABLE_ROOT_KEYS = /* @__PURE__ */ new Set(["then", "catch", "finally"]);
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isPromiseLike(value) {
+  if (!isObjectLike(value)) return false;
+  return typeof Reflect.get(value, "then") === "function";
+}
+export function createIntegratedAuthClient(client, reconciler, track = (operation) => operation) {
+  const wrappedByRaw = /* @__PURE__ */ new WeakMap();
+  const rawByWrapped = /* @__PURE__ */ new WeakMap();
+  const propertyCache = /* @__PURE__ */ new WeakMap();
+  const unwrap = (value) => isObjectLike(value) ? rawByWrapped.get(value) ?? value : value;
+  const wrap = (raw, depth) => {
+    const existing = wrappedByRaw.get(raw);
+    if (existing) return existing;
+    const exposeResult = (value) => {
+      if (!isObjectLike(value)) return value;
+      const known = wrappedByRaw.get(value);
+      if (known) return known;
+      if (rawByWrapped.has(value)) return value;
+      return typeof value === "function" ? wrap(value, depth + 1) : value;
+    };
+    const target = typeof raw === "function" ? (..._arguments) => void 0 : /* @__PURE__ */ Object.create(null);
+    const readExposedProperty = (property) => {
+      let cached = propertyCache.get(raw);
+      if (!cached) {
+        cached = /* @__PURE__ */ new Map();
+        propertyCache.set(raw, cached);
+      }
+      if (cached.has(property)) return cached.get(property);
+      const value = Reflect.get(raw, property, raw);
+      const exposed = isObjectLike(value) ? wrap(value, depth + 1) : value;
+      cached.set(property, exposed);
+      return exposed;
+    };
+    const isHidden = (property) => depth === 0 && (HIDDEN_ROOT_KEYS.has(property) || NON_THENABLE_ROOT_KEYS.has(property));
+    const proxy = new Proxy(target, {
+      get(_target, property) {
+        if (isHidden(property)) return void 0;
+        return readExposedProperty(property);
+      },
+      has(_target, property) {
+        if (isHidden(property)) return false;
+        return Reflect.has(raw, property);
+      },
+      ownKeys(shadow) {
+        const keys = new Set(Reflect.ownKeys(shadow));
+        for (const property of Reflect.ownKeys(raw)) {
+          if (!isHidden(property)) keys.add(property);
+        }
+        return [...keys];
+      },
+      getOwnPropertyDescriptor(shadow, property) {
+        const shadowDescriptor = Reflect.getOwnPropertyDescriptor(shadow, property);
+        if (shadowDescriptor && shadowDescriptor.configurable === false) return shadowDescriptor;
+        if (isHidden(property)) return void 0;
+        const descriptor = Reflect.getOwnPropertyDescriptor(raw, property);
+        if (!descriptor) return shadowDescriptor;
+        return {
+          configurable: true,
+          enumerable: descriptor.enumerable,
+          ...descriptor.get || descriptor.set ? {
+            get: descriptor.get ? () => readExposedProperty(property) : void 0,
+            set: void 0
+          } : {
+            value: readExposedProperty(property),
+            writable: false
+          }
+        };
+      },
+      set() {
+        return false;
+      },
+      defineProperty() {
+        return false;
+      },
+      deleteProperty() {
+        return false;
+      },
+      setPrototypeOf() {
+        return false;
+      },
+      preventExtensions() {
+        return false;
+      },
+      apply(_target, thisArgument, argumentsList) {
+        const checkpoint = reconciler.checkpoint();
+        let result;
+        let promiseLike;
+        try {
+          result = Reflect.apply(
+            raw,
+            unwrap(thisArgument),
+            argumentsList
+          );
+          promiseLike = isPromiseLike(result);
+        } catch (error) {
+          reconciler.cancel(checkpoint);
+          throw error;
+        }
+        if (!promiseLike) {
+          reconciler.cancel(checkpoint);
+          return exposeResult(result);
+        }
+        const reconciled = Promise.resolve(result).then(
+          async (value) => {
+            await reconciler.reconcile(checkpoint);
+            return exposeResult(value);
+          },
+          async (error) => {
+            await reconciler.reconcile(checkpoint);
+            throw error;
+          }
+        );
+        return track(reconciled);
+      }
+    });
+    wrappedByRaw.set(raw, proxy);
+    rawByWrapped.set(proxy, raw);
+    return proxy;
+  };
+  return wrap(client, 0);
+}

package/dist/runtime/auth/operation-tracker.d.ts

@@ -0,0 +1,7 @@
+import { type ComputedRef } from 'vue';
+/** Tracks actual asynchronous Better Auth work without serializing callers. */
+export interface AuthOperationTracker {
+    readonly isPending: ComputedRef<boolean>;
+    track<Value>(operation: Promise<Value>): Promise<Value>;
+}
+export declare function createAuthOperationTracker(): AuthOperationTracker;

package/dist/runtime/auth/operation-tracker.js

@@ -0,0 +1,14 @@
+import { computed, ref } from "vue";
+export function createAuthOperationTracker() {
+  const pendingCount = ref(0);
+  const isPending = computed(() => pendingCount.value > 0);
+  return {
+    isPending,
+    track(operation) {
+      pendingCount.value += 1;
+      return operation.finally(() => {
+        pendingCount.value -= 1;
+      });
+    }
+  };
+}

package/dist/runtime/auth/session-synchronization.d.ts

@@ -0,0 +1,23 @@
+import { ConvexCallError } from '../errors/index.js';
+import type { CanonicalSessionReconciler } from './integrated-client.js';
+export interface ProviderSessionRevision {
+    readonly sessionToken: string | null;
+    readonly revision: number;
+    readonly failed: boolean;
+}
+export interface SessionSynchronization extends CanonicalSessionReconciler {
+    /** Published synchronously by the one Better Auth session observer. */
+    observeProvider(session: ProviderSessionRevision): void;
+    /** Published only after the one Convex runtime has settled this generation. */
+    observeAccepted(session: ProviderSessionRevision, failed: boolean): void;
+    dispose(): void;
+}
+/**
+ * Correlates the canonical Better Auth session revision with Convex runtime
+ * acceptance. Provider tokens remain private to this browser-only boundary.
+ */
+export declare function createSessionSynchronization(input: {
+    timeoutMs: number;
+    refetchCanonicalSession: () => Promise<void>;
+    failClosed: (failure: ConvexCallError) => void;
+}): SessionSynchronization;

package/dist/runtime/auth/session-synchronization.js

@@ -0,0 +1,156 @@
+import { ConvexCallError } from "../errors/index.js";
+const DISPOSED_CODE = "AUTH_CLIENT_DISPOSED";
+const REFRESH_FAILED_CODE = "SESSION_RECONCILIATION_REFRESH_FAILED";
+const RUNTIME_FAILED_CODE = "SESSION_RECONCILIATION_RUNTIME_FAILED";
+const SYNC_CHANGE_CODE = "SYNCHRONOUS_SESSION_CHANGE";
+const TIMEOUT_CODE = "SESSION_RECONCILIATION_TIMEOUT";
+function failure(code, message) {
+  return new ConvexCallError({ kind: "authentication", code, message });
+}
+function sameSession(left, right) {
+  return left.revision === right.revision && left.sessionToken === right.sessionToken;
+}
+export function createSessionSynchronization(input) {
+  let disposed = false;
+  let provider;
+  let accepted;
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const listener of [...listeners]) listener();
+  };
+  const failClosed = (authFailure) => {
+    try {
+      input.failClosed(authFailure);
+    } catch {
+    }
+    throw authFailure;
+  };
+  const assertActive = () => {
+    if (disposed) {
+      throw failure(DISPOSED_CODE, "The integrated authentication client was disposed");
+    }
+  };
+  const waitForNotification = (deadline) => {
+    assertActive();
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      return Promise.reject(failure(TIMEOUT_CODE, "Better Auth session reconciliation timed out"));
+    }
+    return new Promise((resolve, reject) => {
+      let active = true;
+      const finish = (reason) => {
+        if (!active) return;
+        active = false;
+        clearTimeout(timer);
+        listeners.delete(wake);
+        if (reason) reject(reason);
+        else resolve();
+      };
+      const wake = () => finish();
+      const timer = setTimeout(
+        () => finish(failure(TIMEOUT_CODE, "Better Auth session reconciliation timed out")),
+        remaining
+      );
+      listeners.add(wake);
+      if (disposed) {
+        finish(failure(DISPOSED_CODE, "The integrated authentication client was disposed"));
+      }
+    });
+  };
+  const withinDeadline = async (operation, deadline) => {
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) {
+      throw failure(TIMEOUT_CODE, "Better Auth session reconciliation timed out");
+    }
+    let timer;
+    try {
+      return await Promise.race([
+        operation,
+        new Promise((_resolve, reject) => {
+          timer = setTimeout(
+            () => reject(failure(TIMEOUT_CODE, "Better Auth session reconciliation timed out")),
+            remaining
+          );
+        })
+      ]);
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+    }
+  };
+  const waitForProvider = async (deadline) => {
+    for (; ; ) {
+      assertActive();
+      if (provider) return provider;
+      await waitForNotification(deadline);
+    }
+  };
+  const waitForAcceptanceOrChurn = async (expected, deadline) => {
+    for (; ; ) {
+      assertActive();
+      if (provider && !sameSession(provider, expected)) return "changed";
+      if (accepted && sameSession(accepted.session, expected)) {
+        if (accepted.failed) {
+          throw failure(RUNTIME_FAILED_CODE, "Convex rejected the refreshed Better Auth session");
+        }
+        return "accepted";
+      }
+      await waitForNotification(deadline);
+    }
+  };
+  return {
+    observeProvider(session) {
+      if (disposed) return;
+      provider = session;
+      notify();
+    },
+    observeAccepted(session, runtimeFailed) {
+      if (disposed) return;
+      accepted = { session, failed: runtimeFailed };
+      notify();
+    },
+    checkpoint() {
+      assertActive();
+      return { revision: provider?.revision ?? -1 };
+    },
+    cancel(checkpoint) {
+      assertActive();
+      if (provider && provider.revision !== checkpoint.revision) {
+        failClosed(
+          failure(
+            SYNC_CHANGE_CODE,
+            "A synchronous Better Auth operation changed the provider session"
+          )
+        );
+      }
+    },
+    async reconcile(_checkpoint) {
+      assertActive();
+      const deadline = Date.now() + input.timeoutMs;
+      try {
+        for (; ; ) {
+          await withinDeadline(input.refetchCanonicalSession(), deadline);
+          const expected = await waitForProvider(deadline);
+          if (expected.failed) {
+            throw failure(REFRESH_FAILED_CODE, "The canonical Better Auth session refresh failed");
+          }
+          const outcome = await waitForAcceptanceOrChurn(expected, deadline);
+          if (outcome === "accepted") return;
+        }
+      } catch (error) {
+        if (error instanceof ConvexCallError) {
+          if (error.code === DISPOSED_CODE) throw error;
+          failClosed(error);
+        }
+        failClosed(failure(REFRESH_FAILED_CODE, "The canonical Better Auth session refresh failed"));
+      }
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      notify();
+      listeners.clear();
+      provider = void 0;
+      accepted = void 0;
+    }
+  };
+}

package/dist/runtime/auth/token-fetcher.d.ts

@@ -0,0 +1,66 @@
+import { TOKEN_EXPIRY_SAFETY_BUFFER_MS } from '../utils/convex-shared.js';
+import type { ConvexUser } from '../utils/types.js';
+/**
+ * Better Auth Convex-plugin surface used to exchange the session for a JWT.
+ * `convex.token()` returns `{ data: { token } | null, error }` and, with
+ * `fetchOptions.throw = false`, resolves rather than throwing on HTTP failure.
+ */
+export interface ConvexTokenSource {
+    convex: {
+        token: (options?: unknown) => Promise<{
+            data?: {
+                token: string | null;
+            } | null;
+            error?: unknown;
+        }>;
+    };
+}
+/** A confirmed candidate identity produced by a successful token exchange. */
+export interface FetchedIdentity {
+    token: string;
+    user: ConvexUser;
+}
+export { TOKEN_EXPIRY_SAFETY_BUFFER_MS };
+/** Immediate transient-retry attempts bounded by one fixed exchange deadline. */
+export declare const MAX_FETCH_ATTEMPTS = 4;
+/**
+ * A token is retainable only while it carries a valid required `exp` still in
+ * the future beyond the safety buffer. A token without a valid `exp`, or at/after
+ * expiry, is never retained (architecture invariant).
+ */
+export declare function isTokenUsable(token: string | null, nowMs?: number): token is string;
+/**
+ * A settled token WITHOUT a non-empty Better Auth `user.id` is an authentication
+ * error : decode returns null and the token is discarded, never
+ * installed. Returns `null` for a token that decodes to no usable user.
+ */
+export declare function decodeFetchedIdentity(token: string): FetchedIdentity | null;
+/**
+ * The outcome of one total token fetch. `identity: null` with `authError: null`
+ * is a clean anonymous result when the exchange succeeds with no token. A
+ * definitive 401/403 means presented credentials were rejected and is reported
+ * as an authentication error. `authError` is also set when a token decodes
+ * without a stable user id, or a transient transport failure exhausts the retry
+ * loop. `definitive`
+ * distinguishes such a transient (non-definitive) failure — over which a usable
+ * identity is retained — from the definitive verdicts above. Never rejects.
+ */
+export interface FetchOutcome {
+    identity: FetchedIdentity | null;
+    authError: string | null;
+    definitive: boolean;
+}
+/**
+ * Total Convex-token fetch; never throws.
+ *
+ * Runs a bounded transient-retry loop over the Better Auth exchange within one
+ * fixed browser deadline, validating each returned token's `exp`. Returns a
+ * decoded identity on success, a clean anonymous outcome when the exchange
+ * reports no session, or a definitive error outcome when every attempt fails. A
+ * rejecting or never-settling exchange is totalized for the Convex caller.
+ */
+export declare function fetchConvexToken(source: ConvexTokenSource, options?: {
+    maxAttempts?: number;
+    nowMs?: () => number;
+    signal?: AbortSignal;
+}): Promise<FetchOutcome>;

package/dist/runtime/auth/token-fetcher.js

@@ -0,0 +1,131 @@
+import {
+  decodeUserFromJwt,
+  isJwtUsable,
+  TOKEN_EXPIRY_SAFETY_BUFFER_MS
+} from "../utils/convex-shared.js";
+export { TOKEN_EXPIRY_SAFETY_BUFFER_MS };
+export const MAX_FETCH_ATTEMPTS = 4;
+const TOKEN_EXCHANGE_TIMEOUT_MS = 5e3;
+const TOKEN_EXCHANGE_TIMED_OUT = Symbol("TOKEN_EXCHANGE_TIMED_OUT");
+const TOKEN_EXCHANGE_CANCELLED = Symbol("TOKEN_EXCHANGE_CANCELLED");
+const TOKEN_EXCHANGE_TIMEOUT_MESSAGE = "Convex authentication token exchange timed out";
+const TOKEN_EXCHANGE_CANCELLED_MESSAGE = "Convex authentication token exchange was cancelled";
+const TOKEN_EXCHANGE_FAILURE_MESSAGE = "Authentication is temporarily unavailable";
+export function isTokenUsable(token, nowMs = Date.now()) {
+  return isJwtUsable(token, nowMs);
+}
+export function decodeFetchedIdentity(token) {
+  const user = decodeUserFromJwt(token);
+  if (!user || typeof user.id !== "string" || user.id.length === 0) return null;
+  return { token, user };
+}
+export async function fetchConvexToken(source, options = {}) {
+  if (options.signal?.aborted) {
+    return {
+      identity: null,
+      authError: TOKEN_EXCHANGE_CANCELLED_MESSAGE,
+      definitive: false
+    };
+  }
+  const maxAttempts = options.maxAttempts ?? MAX_FETCH_ATTEMPTS;
+  const now = options.nowMs ?? Date.now;
+  let lastError = null;
+  const controller = new AbortController();
+  let timedOut = false;
+  let externallyCancelled = false;
+  let timeout = null;
+  const deadline = new Promise((resolve) => {
+    timeout = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+      resolve(TOKEN_EXCHANGE_TIMED_OUT);
+    }, TOKEN_EXCHANGE_TIMEOUT_MS);
+  });
+  let removeExternalAbort = () => {
+  };
+  const cancellation = new Promise((resolve) => {
+    const externalSignal = options.signal;
+    if (!externalSignal) return;
+    const cancel = () => {
+      externallyCancelled = true;
+      resolve(TOKEN_EXCHANGE_CANCELLED);
+      controller.abort();
+    };
+    externalSignal.addEventListener("abort", cancel, { once: true });
+    removeExternalAbort = () => externalSignal.removeEventListener("abort", cancel);
+    if (externalSignal.aborted) cancel();
+  });
+  try {
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      if (externallyCancelled) {
+        lastError = TOKEN_EXCHANGE_CANCELLED_MESSAGE;
+        break;
+      }
+      try {
+        const exchange = source.convex.token({
+          fetchOptions: { throw: false, signal: controller.signal }
+        });
+        const response = await Promise.race([exchange, deadline, cancellation]);
+        if (response === TOKEN_EXCHANGE_CANCELLED) {
+          lastError = TOKEN_EXCHANGE_CANCELLED_MESSAGE;
+          break;
+        }
+        if (response === TOKEN_EXCHANGE_TIMED_OUT) {
+          lastError = TOKEN_EXCHANGE_TIMEOUT_MESSAGE;
+          break;
+        }
+        if (response.error) {
+          if (isDefinitiveAuthStatus(response.error)) {
+            return {
+              identity: null,
+              authError: "Authentication credentials are invalid or expired",
+              definitive: true
+            };
+          }
+          lastError = TOKEN_EXCHANGE_FAILURE_MESSAGE;
+          continue;
+        }
+        const token = response.data?.token;
+        if (!token) {
+          return { identity: null, authError: null, definitive: true };
+        }
+        if (!isTokenUsable(token, now())) {
+          lastError = "Convex authentication token is expired or missing a valid expiry";
+          continue;
+        }
+        const identity = decodeFetchedIdentity(token);
+        if (!identity) {
+          return {
+            identity: null,
+            authError: "Convex authentication token is missing a stable user id",
+            definitive: true
+          };
+        }
+        return { identity, authError: null, definitive: false };
+      } catch {
+        if (externallyCancelled) {
+          lastError = TOKEN_EXCHANGE_CANCELLED_MESSAGE;
+          break;
+        }
+        if (timedOut) {
+          lastError = TOKEN_EXCHANGE_TIMEOUT_MESSAGE;
+          break;
+        }
+        lastError = TOKEN_EXCHANGE_FAILURE_MESSAGE;
+      }
+    }
+  } finally {
+    removeExternalAbort();
+    if (timeout !== null) clearTimeout(timeout);
+  }
+  return {
+    identity: null,
+    authError: lastError ?? TOKEN_EXCHANGE_FAILURE_MESSAGE,
+    definitive: false
+  };
+}
+function isDefinitiveAuthStatus(error) {
+  if (!error || typeof error !== "object") return false;
+  const status = error.status;
+  return status === 401 || status === 403;
+}

package/dist/runtime/auth/validate-auth-client-definition.d.ts

@@ -0,0 +1,12 @@
+import type { ConvexAuthClientDefinition } from '../auth-client/index.js';
+import type { AuthClientPlugins, ConvexAuthClientDefinitionOptions } from '../auth-client/definition-types.js';
+export declare class ConvexAuthClientDefinitionError extends TypeError {
+    constructor(message: string);
+}
+/**
+ * Validate a resolved definition object and return its `options`. Throws a
+ * `ConvexAuthClientDefinitionError` on any forbidden key, non-array/malformed
+ * `plugins`, or a consumer plugin whose stable `id` collides with the reserved
+ * Convex plugin id.
+ */
+export declare function validateConvexAuthClientDefinition<Plugins extends AuthClientPlugins>(definition: ConvexAuthClientDefinition<Plugins> | unknown): ConvexAuthClientDefinitionOptions<Plugins>;

package/dist/runtime/auth/validate-auth-client-definition.js

@@ -0,0 +1,47 @@
+const FORBIDDEN_OWN_KEYS = ["baseURL", "basePath", "fetchOptions"];
+const CONVEX_PLUGIN_ID = "convex";
+export class ConvexAuthClientDefinitionError extends TypeError {
+  constructor(message) {
+    super(`[better-convex-nuxt] invalid auth-client definition: ${message}`);
+    this.name = "ConvexAuthClientDefinitionError";
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+export function validateConvexAuthClientDefinition(definition) {
+  if (!isRecord(definition) || !isRecord(definition.options)) {
+    throw new ConvexAuthClientDefinitionError(
+      "expected a `defineConvexAuthClient({ ... })` result with an `options` object."
+    );
+  }
+  const options = definition.options;
+  for (const key of FORBIDDEN_OWN_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(options, key)) {
+      throw new ConvexAuthClientDefinitionError(
+        `\`${key}\` is owned by the module and cannot be set on the definition.`
+      );
+    }
+  }
+  const { plugins } = options;
+  if (plugins !== void 0) {
+    if (!Array.isArray(plugins)) {
+      throw new ConvexAuthClientDefinitionError(
+        "`plugins` must be an array of Better Auth client plugins."
+      );
+    }
+    for (const [index, plugin] of plugins.entries()) {
+      if (!isRecord(plugin) || typeof plugin.id !== "string") {
+        throw new ConvexAuthClientDefinitionError(
+          `plugins[${index}] is not a valid Better Auth client plugin (missing string \`id\`).`
+        );
+      }
+      if (plugin.id === CONVEX_PLUGIN_ID) {
+        throw new ConvexAuthClientDefinitionError(
+          `plugins[${index}] uses the reserved id \`${CONVEX_PLUGIN_ID}\`; the module prepends the Convex client plugin itself.`
+        );
+      }
+    }
+  }
+  return options;
+}

package/dist/runtime/auth-client/convex-client-plugin.d.ts

@@ -0,0 +1,31 @@
+interface ConvexTokenActionOptions {
+    fetchOptions?: Record<string, unknown>;
+}
+/**
+ * Internal Better Auth client action for the fixed Convex session-token route.
+ * Consumers cannot supply or replace this plugin.
+ */
+export declare function convexClientPlugin(): {
+    id: "convex";
+    pathMethods: {
+        '/convex/token': "GET";
+    };
+    getActions: ($fetch: import("better-auth/vue").BetterFetch) => {
+        convex: {
+            token: (options?: ConvexTokenActionOptions) => Promise<{
+                data: {
+                    token: string | null;
+                };
+                error: null;
+            } | {
+                data: null;
+                error: {
+                    message?: string | undefined;
+                    status: number;
+                    statusText: string;
+                };
+            }>;
+        };
+    };
+};
+export {};

package/dist/runtime/auth-client/convex-client-plugin.js

@@ -0,0 +1,14 @@
+export function convexClientPlugin() {
+  return {
+    id: "convex",
+    pathMethods: { "/convex/token": "GET" },
+    getActions: ($fetch) => ({
+      convex: {
+        token: async (options) => await $fetch("/convex/token", {
+          ...options?.fetchOptions ?? {},
+          method: "GET"
+        })
+      }
+    })
+  };
+}

package/dist/runtime/auth-client/definition-types.d.ts

@@ -0,0 +1,6 @@
+import type { BetterAuthClientOptions, BetterAuthClientPlugin } from 'better-auth/client';
+/** Internal generic inputs shared by the public definition and its runtime validator. */
+export type AuthClientPlugins = readonly BetterAuthClientPlugin[];
+export type ConvexAuthClientDefinitionOptions<Plugins extends AuthClientPlugins> = Omit<BetterAuthClientOptions, 'baseURL' | 'basePath' | 'plugins' | 'fetchOptions'> & {
+    plugins?: Plugins;
+};

package/dist/runtime/auth-client/empty-definition.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("./index.js").ConvexAuthClientDefinition<[]>;
+export default _default;

package/dist/runtime/auth-client/empty-definition.js

@@ -0,0 +1,2 @@
+import { defineConvexAuthClient } from "./index.js";
+export default defineConvexAuthClient();