better-convex 0.9.2 → 0.10.0

package/dist/auth/index.d.ts

@@ -197,8 +197,8 @@ declare const adapterArgsValidator: convex_values0.VObject<{
   select?: string[] | undefined;
   offset?: number | undefined;
   sortBy?: {
-    direction: "asc" | "desc";
     field: string;
+    direction: "asc" | "desc";
   } | undefined;
   where?: {
     connector?: "AND" | "OR" | undefined;
@@ -213,12 +213,12 @@ declare const adapterArgsValidator: convex_values0.VObject<{
   offset: convex_values0.VFloat64<number | undefined, "optional">;
   select: convex_values0.VArray<string[] | undefined, convex_values0.VString<string, "required">, "optional">;
   sortBy: convex_values0.VObject<{
-    direction: "asc" | "desc";
     field: string;
+    direction: "asc" | "desc";
   } | undefined, {
     direction: convex_values0.VUnion<"asc" | "desc", [convex_values0.VLiteral<"asc", "required">, convex_values0.VLiteral<"desc", "required">], "required", never>;
     field: convex_values0.VString<string, "required">;
-  }, "optional", "direction" | "field">;
+  }, "optional", "field" | "direction">;
   where: convex_values0.VArray<{
     connector?: "AND" | "OR" | undefined;
     operator?: "in" | "lt" | "lte" | "gt" | "gte" | "eq" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined;
@@ -235,7 +235,7 @@ declare const adapterArgsValidator: convex_values0.VObject<{
     operator: convex_values0.VUnion<"in" | "lt" | "lte" | "gt" | "gte" | "eq" | "not_in" | "ne" | "contains" | "starts_with" | "ends_with" | undefined, [convex_values0.VLiteral<"lt", "required">, convex_values0.VLiteral<"lte", "required">, convex_values0.VLiteral<"gt", "required">, convex_values0.VLiteral<"gte", "required">, convex_values0.VLiteral<"eq", "required">, convex_values0.VLiteral<"in", "required">, convex_values0.VLiteral<"not_in", "required">, convex_values0.VLiteral<"ne", "required">, convex_values0.VLiteral<"contains", "required">, convex_values0.VLiteral<"starts_with", "required">, convex_values0.VLiteral<"ends_with", "required">], "optional", never>;
     value: convex_values0.VUnion<string | number | boolean | string[] | number[] | null, [convex_values0.VString<string, "required">, convex_values0.VFloat64<number, "required">, convex_values0.VBoolean<boolean, "required">, convex_values0.VArray<string[], convex_values0.VString<string, "required">, "required">, convex_values0.VArray<number[], convex_values0.VFloat64<number, "required">, "required">, convex_values0.VNull<null, "required">], "required", never>;
   }, "required", "value" | "connector" | "field" | "operator">, "optional">;
-}, "required", "limit" | "model" | "select" | "offset" | "sortBy" | "where" | "sortBy.direction" | "sortBy.field">;
+}, "required", "limit" | "model" | "select" | "offset" | "sortBy" | "where" | "sortBy.field" | "sortBy.direction">;
 declare const hasUniqueFields: (betterAuthSchema: BetterAuthDBSchema, model: string, input: Record<string, any>) => boolean;
 declare const checkUniqueFields: <Schema extends SchemaDefinition<any, any>>(ctx: GenericQueryCtx<GenericDataModel>, schema: Schema, betterAuthSchema: BetterAuthDBSchema, table: string, input: Record<string, any>, doc?: Record<string, any>) => Promise<void>;
 declare const selectFields: <T extends TableNamesInDataModel<GenericDataModel>, D extends DocumentByName<GenericDataModel, T>>(doc: D | null, select?: string[]) => Promise<D | null>;
@@ -407,8 +407,8 @@ declare const createApi: <Schema extends SchemaDefinition<any, any>, DataModel e
     join?: any;
     offset?: number | undefined;
     sortBy?: {
-      direction: "asc" | "desc";
       field: string;
+      direction: "asc" | "desc";
     } | undefined;
     where?: {
       connector?: "AND" | "OR" | undefined;
@@ -19203,8 +19203,8 @@ declare const createAuthRuntime: <DataModel extends GenericDataModel, Schema ext
     join?: any;
     offset?: number | undefined;
     sortBy?: {
-      direction: "asc" | "desc";
       field: string;
+      direction: "asc" | "desc";
     } | undefined;
     where?: {
       connector?: "AND" | "OR" | undefined;

package/dist/crpc/index.d.ts

@@ -1,7 +1,36 @@
 import { $ as identityTransformer, G as DataTransformerOptions, H as CombinedDataTransformer, J as dateWireCodec, K as WireCodec, Q as getTransformer, U as DATE_CODEC_TAG, W as DataTransformer, X as defaultCRPCTransformer, Y as decodeWire, Z as encodeWire, a as HttpProcedureCall, c as InferHttpInput, i as HttpErrorCode, l as InferHttpOutput, n as HttpClientError, o as HttpRouteInfo, q as createTaggedTransformer, r as HttpClientFromRouter, s as HttpRouteMap, t as HttpClient, u as isHttpClientError } from "../http-types-BK7FuIcR.js";
-import { C as PaginatedFnMeta, D as VanillaMutation, E as VanillaCRPCClient, O as VanillaQuery, S as Meta, T as VanillaAction, _ as ExtractPaginatedItem, a as ConvexInfiniteQueryMeta, b as InfiniteQueryInput, c as ConvexMutationKey, d as ConvexQueryMeta, f as ConvexQueryOptions, g as DecorateQuery, h as DecorateMutation, i as ConvexActionOptions, l as ConvexQueryHookOptions, m as DecorateInfiniteQuery, n as CRPCClient, o as ConvexInfiniteQueryOptions, p as DecorateAction, r as ConvexActionKey, s as ConvexInfiniteQueryOptionsWithRef, t as AuthType, u as ConvexQueryKey, v as FUNC_REF_SYMBOL, w as PaginationOpts, x as InfiniteQueryOptsParam, y as FnMeta } from "../types-f53SgpBL.js";
+import { A as HttpInputArgs, C as ReservedMutationOptions, D as VanillaMutation, E as VanillaAction, F as replaceUrlParam, M as RESERVED_KEYS, N as buildSearchParams, O as HttpClientOptions, P as executeHttpRequest, S as ReservedInfiniteQueryOptions, T as StaticQueryOptsParam, _ as IsPaginated, a as BaseInfiniteQueryOptsParam, b as PaginatedFnMeta, c as ConvexMutationKey, d as ConvexQueryMeta, f as EmptyObject, g as InfiniteQueryInput, h as FnMeta, i as BaseConvexQueryOptions, j as HttpProxyBaseOptions, k as HttpFormValue, l as ConvexQueryHookOptions, m as FUNC_REF_SYMBOL, n as BaseConvexActionOptions, o as ConvexActionKey, p as ExtractPaginatedItem, r as BaseConvexInfiniteQueryOptions, s as ConvexInfiniteQueryMeta, t as AuthType, u as ConvexQueryKey, v as Meta, w as ReservedQueryOptions, x as PaginationOpts, y as MutationVariables } from "../types-7bF_8IjP.js";
 import { FunctionArgs, FunctionReference } from "convex/server";
 
+//#region src/crpc/auth-error.d.ts
+/**
+ * Auth Mutation Error
+ *
+ * Framework-agnostic error class for Better Auth mutations.
+ */
+/**
+ * Error thrown when a Better Auth mutation fails.
+ * Contains the original error details from Better Auth.
+ */
+declare class AuthMutationError extends Error {
+  /** Error code from Better Auth (e.g., 'INVALID_PASSWORD', 'EMAIL_ALREADY_REGISTERED') */
+  code?: string;
+  /** HTTP status code */
+  status: number;
+  /** HTTP status text */
+  statusText: string;
+  constructor(authError: {
+    message?: string;
+    status: number;
+    statusText: string;
+    code?: string;
+  });
+}
+/**
+ * Type guard to check if an error is an AuthMutationError.
+ */
+declare function isAuthMutationError(error: unknown): error is AuthMutationError;
+//#endregion
 //#region src/crpc/error.d.ts
 /**
  * Client error codes (subset of CRPC codes for client-side use)
@@ -40,7 +69,7 @@ declare const defaultIsUnauthorized: (error: unknown) => boolean;
  */
 declare function convexQuery<T extends FunctionReference<'query'>>(funcRef: T, args?: FunctionArgs<T> | 'skip', meta?: Meta, opts?: {
   skipUnauth?: boolean;
-}): ConvexQueryOptions<T> & {
+}): BaseConvexQueryOptions<T> & {
   meta: ConvexQueryMeta;
 };
 /**
@@ -62,7 +91,7 @@ declare function convexQuery<T extends FunctionReference<'query'>>(funcRef: T, a
  */
 declare function convexAction<T extends FunctionReference<'action'>>(funcRef: T, args?: FunctionArgs<T> | 'skip', meta?: Meta, opts?: {
   skipUnauth?: boolean;
-}): ConvexActionOptions<T> & {
+}): BaseConvexActionOptions<T> & {
   meta: ConvexQueryMeta;
 };
 /**
@@ -71,6 +100,6 @@ declare function convexAction<T extends FunctionReference<'action'>>(funcRef: T,
  *
  * Uses flat { cursor, limit } input like tRPC.
  */
-declare function convexInfiniteQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: Record<string, unknown> | 'skip', opts?: InfiniteQueryOptsParam<T>, meta?: Meta): ConvexInfiniteQueryOptions<T>;
+declare function convexInfiniteQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: Record<string, unknown> | 'skip', opts?: BaseInfiniteQueryOptsParam<T> & Record<string, unknown>, meta?: Meta): BaseConvexInfiniteQueryOptions<T> & Record<string, unknown>;
 //#endregion
-export { AuthType, CRPCClient, CRPCClientError, CombinedDataTransformer, ConvexActionKey, ConvexActionOptions, ConvexInfiniteQueryMeta, ConvexInfiniteQueryOptions, ConvexInfiniteQueryOptionsWithRef, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, ConvexQueryOptions, DATE_CODEC_TAG, DataTransformer, DataTransformerOptions, DecorateAction, DecorateInfiniteQuery, DecorateMutation, DecorateQuery, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HttpClient, HttpClientError, HttpClientFromRouter, HttpErrorCode, HttpProcedureCall, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, InfiniteQueryOptsParam, Meta, PaginatedFnMeta, PaginationOpts, VanillaAction, VanillaCRPCClient, VanillaMutation, VanillaQuery, WireCodec, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, getTransformer, identityTransformer, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError };
+export { AuthMutationError, AuthType, BaseConvexActionOptions, BaseConvexInfiniteQueryOptions, BaseConvexQueryOptions, BaseInfiniteQueryOptsParam, CRPCClientError, CombinedDataTransformer, ConvexActionKey, ConvexInfiniteQueryMeta, ConvexMutationKey, ConvexQueryHookOptions, ConvexQueryKey, ConvexQueryMeta, DATE_CODEC_TAG, DataTransformer, DataTransformerOptions, EmptyObject, ExtractPaginatedItem, FUNC_REF_SYMBOL, FnMeta, HttpClient, HttpClientError, HttpClientFromRouter, HttpClientOptions, HttpErrorCode, HttpFormValue, HttpInputArgs, HttpProcedureCall, HttpProxyBaseOptions, HttpRouteInfo, HttpRouteMap, InferHttpInput, InferHttpOutput, InfiniteQueryInput, IsPaginated, Meta, MutationVariables, PaginatedFnMeta, PaginationOpts, RESERVED_KEYS, ReservedInfiniteQueryOptions, ReservedMutationOptions, ReservedQueryOptions, StaticQueryOptsParam, VanillaAction, VanillaMutation, WireCodec, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };

package/dist/crpc/index.js

@@ -2,6 +2,39 @@ import { a as isCRPCErrorCode, i as isCRPCError, n as defaultIsUnauthorized, r a
 import { a as defaultCRPCTransformer, c as identityTransformer, i as decodeWire, n as createTaggedTransformer, o as encodeWire, r as dateWireCodec, s as getTransformer, t as DATE_CODEC_TAG } from "../transformer-ogg-4d78.js";
 import { n as convexInfiniteQueryOptions, r as convexQuery, t as convexAction } from "../query-options-CSCmKYdJ.js";
 
+//#region src/crpc/auth-error.ts
+/**
+* Auth Mutation Error
+*
+* Framework-agnostic error class for Better Auth mutations.
+*/
+/**
+* Error thrown when a Better Auth mutation fails.
+* Contains the original error details from Better Auth.
+*/
+var AuthMutationError = class extends Error {
+	/** Error code from Better Auth (e.g., 'INVALID_PASSWORD', 'EMAIL_ALREADY_REGISTERED') */
+	code;
+	/** HTTP status code */
+	status;
+	/** HTTP status text */
+	statusText;
+	constructor(authError) {
+		super(authError.message || authError.statusText);
+		this.name = "AuthMutationError";
+		this.code = authError.code;
+		this.status = authError.status;
+		this.statusText = authError.statusText;
+	}
+};
+/**
+* Type guard to check if an error is an AuthMutationError.
+*/
+function isAuthMutationError(error) {
+	return error instanceof AuthMutationError;
+}
+
+//#endregion
 //#region src/crpc/http-types.ts
 /** HTTP client error */
 var HttpClientError = class extends Error {
@@ -19,10 +52,118 @@ var HttpClientError = class extends Error {
 /** Type guard for HttpClientError */
 const isHttpClientError = (error) => error instanceof HttpClientError;
 
+//#endregion
+//#region src/crpc/http-client.ts
+/**
+* HTTP Client Helpers
+*
+* Framework-agnostic utilities for executing HTTP requests
+* against Convex HTTP endpoints.
+*/
+/** Reserved keys that are not part of JSON body */
+const RESERVED_KEYS = new Set([
+	"params",
+	"searchParams",
+	"form",
+	"fetch",
+	"init",
+	"headers"
+]);
+/**
+* Replace URL path parameters with actual values.
+* e.g., '/users/:id' with { id: '123' } -> '/users/123'
+*/
+function replaceUrlParam(url, params) {
+	return url.replace(/:(\w+)/g, (_, key) => {
+		const value = params[key];
+		return value !== void 0 ? encodeURIComponent(value) : `:${key}`;
+	});
+}
+/**
+* Build URLSearchParams from query object.
+* Handles array values as multiple params with same key (like Hono).
+*/
+function buildSearchParams(query) {
+	const params = new URLSearchParams();
+	for (const [key, value] of Object.entries(query)) if (Array.isArray(value)) for (const v of value) params.append(key, v);
+	else if (value !== void 0 && value !== null) params.append(key, value);
+	return params;
+}
+/**
+* Hono-style HTTP request executor.
+* Processes args in the same way as Hono's ClientRequestImpl.fetch().
+*/
+async function executeHttpRequest(opts) {
+	const { method, path } = opts.route;
+	const args = opts.args ?? {};
+	let rBody;
+	let cType;
+	if (args.form) {
+		const form = new FormData();
+		for (const [k, v] of Object.entries(args.form)) if (Array.isArray(v)) for (const v2 of v) form.append(k, v2);
+		else form.append(k, v);
+		rBody = form;
+	} else {
+		const jsonBody = {};
+		for (const [key, value] of Object.entries(args)) if (!RESERVED_KEYS.has(key) && value !== void 0) jsonBody[key] = value;
+		if (Object.keys(jsonBody).length > 0) {
+			rBody = JSON.stringify(opts.transformer.input.serialize(jsonBody));
+			cType = "application/json";
+		}
+	}
+	const argsClientOpts = {};
+	if (args.fetch) argsClientOpts.fetch = args.fetch;
+	if (args.init) argsClientOpts.init = args.init;
+	if (args.headers) argsClientOpts.headers = args.headers;
+	const mergedClientOpts = {
+		...opts.clientOpts,
+		...argsClientOpts
+	};
+	const resolvedBaseHeaders = typeof opts.baseHeaders === "function" ? await opts.baseHeaders() : opts.baseHeaders;
+	const headerValues = { ...typeof mergedClientOpts.headers === "function" ? await mergedClientOpts.headers() : mergedClientOpts.headers };
+	if (cType) headerValues["Content-Type"] = cType;
+	const finalHeaders = {};
+	if (resolvedBaseHeaders) {
+		for (const [key, value] of Object.entries(resolvedBaseHeaders)) if (value !== void 0) finalHeaders[key] = value;
+	}
+	Object.assign(finalHeaders, headerValues);
+	let url = opts.convexSiteUrl + path;
+	if (args.params) url = opts.convexSiteUrl + replaceUrlParam(path, args.params);
+	if (args.searchParams) {
+		const queryString = buildSearchParams(args.searchParams).toString();
+		if (queryString) url = `${url}?${queryString}`;
+	}
+	const methodUpperCase = method.toUpperCase();
+	const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+	const response = await (mergedClientOpts.fetch ?? opts.baseFetch ?? globalThis.fetch)(url, {
+		body: setBody ? rBody : void 0,
+		method: methodUpperCase,
+		headers: finalHeaders,
+		...mergedClientOpts.init
+	});
+	if (!response.ok) {
+		const errorData = await response.json().catch(() => ({ error: {
+			code: "UNKNOWN",
+			message: response.statusText
+		} }));
+		const errorCode = errorData?.error?.code || "UNKNOWN";
+		const errorMessage = errorData?.error?.message || response.statusText;
+		throw new HttpClientError({
+			code: errorCode,
+			status: response.status,
+			procedureName: opts.procedureName,
+			message: errorMessage
+		});
+	}
+	if (response.headers.get("content-length") === "0" || response.status === 204) return;
+	if ((response.headers.get("content-type") || "").includes("application/json")) return opts.transformer.output.deserialize(await response.json());
+	return response.text();
+}
+
 //#endregion
 //#region src/crpc/types.ts
 /** Symbol key for attaching FunctionReference to options (non-serializable) */
 const FUNC_REF_SYMBOL = Symbol.for("convex.funcRef");
 
 //#endregion
-export { CRPCClientError, DATE_CODEC_TAG, FUNC_REF_SYMBOL, HttpClientError, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, getTransformer, identityTransformer, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError };
+export { AuthMutationError, CRPCClientError, DATE_CODEC_TAG, FUNC_REF_SYMBOL, HttpClientError, RESERVED_KEYS, buildSearchParams, convexAction, convexInfiniteQueryOptions, convexQuery, createTaggedTransformer, dateWireCodec, decodeWire, defaultCRPCTransformer, defaultIsUnauthorized, encodeWire, executeHttpRequest, getTransformer, identityTransformer, isAuthMutationError, isCRPCClientError, isCRPCError, isCRPCErrorCode, isHttpClientError, replaceUrlParam };

package/dist/orm/index.js

@@ -2075,6 +2075,12 @@ function findRelationIndex(table, columns, relationName, targetTableName, strict
 const PUBLIC_CREATED_AT_FIELD = "createdAt";
 const INTERNAL_CREATION_TIME_FIELD = "_creationTime";
 const CREATED_AT_MIGRATION_MESSAGE = "`_creationTime` is no longer public. Use `createdAt` instead.";
+const hasUserCreatedAtColumn = (table) => {
+	if (!table || typeof table !== "object") return false;
+	const columns = table[Columns];
+	if (!columns || typeof columns !== "object") return false;
+	return Object.hasOwn(columns, PUBLIC_CREATED_AT_FIELD);
+};
 const usesSystemCreatedAtAlias = (_table) => true;
 
 //#endregion
@@ -2176,10 +2182,11 @@ const normalizePublicSystemFields = (value, options) => {
 };
 const normalizeDateFieldsForWrite = (table, value) => {
 	const useSystemCreatedAt = usesSystemCreatedAtAlias(table);
+	const hasUserCreatedAt = hasUserCreatedAtColumn(table);
 	const temporalColumns = getTemporalColumnDescriptors(table);
 	const result = { ...value };
 	if (Object.hasOwn(result, INTERNAL_CREATION_TIME_FIELD)) throw new Error(CREATED_AT_MIGRATION_MESSAGE);
-	if (useSystemCreatedAt && Object.hasOwn(result, PUBLIC_CREATED_AT_FIELD)) delete result[PUBLIC_CREATED_AT_FIELD];
+	if (useSystemCreatedAt && !hasUserCreatedAt && Object.hasOwn(result, PUBLIC_CREATED_AT_FIELD)) delete result[PUBLIC_CREATED_AT_FIELD];
 	for (const [name, descriptor] of temporalColumns.entries()) {
 		if (!Object.hasOwn(result, name)) continue;
 		result[name] = normalizeTemporalWriteValue(descriptor, result[name]);

package/dist/react/index.d.ts

@@ -10,7 +10,12 @@ import { ConvexHttpClient } from "convex/browser";
 import * as jotai_vanilla0 from "jotai/vanilla";
 import { z } from "zod";
 
-//#region src/react/auth-mutations.d.ts
+//#region src/crpc/auth-error.d.ts
+/**
+ * Auth Mutation Error
+ *
+ * Framework-agnostic error class for Better Auth mutations.
+ */
 /**
  * Error thrown when a Better Auth mutation fails.
  * Contains the original error details from Better Auth.
@@ -33,6 +38,8 @@ declare class AuthMutationError extends Error {
  * Type guard to check if an error is an AuthMutationError.
  */
 declare function isAuthMutationError(error: unknown): error is AuthMutationError;
+//#endregion
+//#region src/react/auth-mutations.d.ts
 type MutationOptionsHook<TData, TVariables = void> = (options?: Omit<UseMutationOptions<TData, DefaultError, TVariables>, 'mutationFn'>) => UseMutationOptions<TData, DefaultError, TVariables>;
 type AnyFn = (...args: any[]) => Promise<any>;
 type AuthClient = {
@@ -534,6 +541,8 @@ declare const FUNC_REF_SYMBOL: unique symbol;
 type ReservedQueryOptions$2 = 'queryKey' | 'queryFn' | 'staleTime';
 /** Options controlled by mutation factories */
 type ReservedMutationOptions$2 = 'mutationFn';
+/** Reserved options controlled by infinite query factories */
+type ReservedInfiniteQueryOptions = 'queryKey' | 'queryFn' | 'staleTime' | 'refetchInterval' | 'refetchOnMount' | 'refetchOnReconnect' | 'refetchOnWindowFocus' | 'persister' | 'placeholderData';
 /** Metadata for a single Convex function */
 type FnMeta$1 = {
   auth?: 'required' | 'optional';
@@ -569,10 +578,6 @@ type ConvexQueryMeta = {
   skipUnauth?: boolean; /** Whether to create WebSocket subscription (default: true) */
   subscribe?: boolean;
 };
-/** Options returned by `convexQuery` factory */
-type ConvexQueryOptions<T extends FunctionReference<'query'>> = Pick<UseQueryOptions<FunctionReturnType<T>, Error, FunctionReturnType<T>, ConvexQueryKey<T>>, 'queryKey' | 'staleTime' | 'enabled'>;
-/** Options returned by `convexAction` factory */
-type ConvexActionOptions<T extends FunctionReference<'action'>> = Pick<UseQueryOptions<FunctionReturnType<T>, Error, FunctionReturnType<T>, ConvexActionKey<T>>, 'queryKey' | 'staleTime' | 'enabled'>;
 /** Hook options for Convex queries */
 type ConvexQueryHookOptions = {
   /** Skip query silently when unauthenticated (default: false, calls onQueryUnauthorized) */skipUnauth?: boolean; /** Set to false to fetch once without subscribing (default: true) */
@@ -584,7 +589,36 @@ type InfiniteQueryInput<TInput> = Omit<TInput, 'cursor' | 'limit'>;
 type ExtractPaginatedItem<TOutput> = TOutput extends {
   page: (infer T)[];
 } ? T : never;
+/** Metadata for infinite query (extends ConvexQueryMeta) */
+type ConvexInfiniteQueryMeta = ConvexQueryMeta & {
+  /** The query function name (serializable for RSC) */queryName: string; /** Query args without cursor/limit (user's filter args only) */
+  args: Record<string, unknown>; /** Items per page (optional - server uses .paginated() default) */
+  limit?: number;
+};
 type EmptyObject = Record<string, never>;
+/** Static query options parameter type (non-hook, for event handlers) */
+type StaticQueryOptsParam = {
+  skipUnauth?: boolean;
+};
+/** Check if a type has cursor key (pagination detection) */
+type IsPaginated<T> = 'cursor' extends keyof T ? true : false;
+/** Mutation variables type - undefined when no args required (allows mutateAsync() without args) */
+type MutationVariables<T extends FunctionReference<'mutation' | 'action'>> = keyof FunctionArgs<T> extends never ? void : EmptyObject extends FunctionArgs<T> ? FunctionArgs<T> | undefined : FunctionArgs<T>;
+/** Vanilla mutation - direct .mutate() call without TanStack Query */
+type VanillaMutation<T extends FunctionReference<'mutation'>> = {
+  mutate: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
+};
+/** Vanilla action - both .query() and .mutate() for direct calls */
+type VanillaAction<T extends FunctionReference<'action'>> = {
+  query: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
+  mutate: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
+};
+//#endregion
+//#region src/react/crpc-types.d.ts
+/** Options returned by `convexQuery` factory */
+type ConvexQueryOptions<T extends FunctionReference<'query'>> = Pick<UseQueryOptions<FunctionReturnType<T>, Error, FunctionReturnType<T>, ConvexQueryKey<T>>, 'queryKey' | 'staleTime' | 'enabled'>;
+/** Options returned by `convexAction` factory */
+type ConvexActionOptions<T extends FunctionReference<'action'>> = Pick<UseQueryOptions<FunctionReturnType<T>, Error, FunctionReturnType<T>, ConvexActionKey<T>>, 'queryKey' | 'staleTime' | 'enabled'>;
 /** Query options parameter type */
 type QueryOptsParam<T extends FunctionReference<'query'>> = Simplify<ConvexQueryHookOptions & DistributiveOmit<UseQueryOptions<FunctionReturnType<T>, DefaultError>, ReservedQueryOptions$2>>;
 /** Query options return type */
@@ -600,10 +634,6 @@ type ActionQueryOptsReturn<T extends FunctionReference<'action'>> = ConvexAction
  * Args are optional when the function has no required parameters.
  * Supports skipToken for type-safe conditional queries.
  */
-/** Static query options parameter type (non-hook, for event handlers) */
-type StaticQueryOptsParam = {
-  skipUnauth?: boolean;
-};
 type DecorateQuery<T extends FunctionReference<'query'>> = {
   queryOptions: keyof FunctionArgs<T> extends never ? (args?: EmptyObject | SkipToken, opts?: QueryOptsParam<T>) => QueryOptsReturn<T> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T> | SkipToken, opts?: QueryOptsParam<T>) => QueryOptsReturn<T> : (args: FunctionArgs<T> | SkipToken, opts?: QueryOptsParam<T>) => QueryOptsReturn<T>; /** Static (non-hook) query options for event handlers and prefetching */
   staticQueryOptions: keyof FunctionArgs<T> extends never ? (args?: EmptyObject | SkipToken, opts?: StaticQueryOptsParam) => ConvexQueryOptions<T> & {
@@ -616,20 +646,12 @@ type DecorateQuery<T extends FunctionReference<'query'>> = {
   queryKey: (args?: DeepPartial<FunctionArgs<T>>) => ConvexQueryKey<T>; /** Get query filter for QueryClient methods (invalidateQueries, removeQueries, etc.) */
   queryFilter: (args?: DeepPartial<FunctionArgs<T>>, filters?: DistributiveOmit<QueryFilters, 'queryKey'>) => QueryFilters;
 };
-/** Reserved options controlled by infinite query factories */
-type ReservedInfiniteQueryOptions = 'queryKey' | 'queryFn' | 'staleTime' | 'refetchInterval' | 'refetchOnMount' | 'refetchOnReconnect' | 'refetchOnWindowFocus' | 'persister' | 'placeholderData';
 /** Options for infinite query - extends TanStack Query options */
 type InfiniteQueryOptsParam<T extends FunctionReference<'query'> = FunctionReference<'query'>> = {
   /** Items per page. Optional - server uses .paginated() default if not provided. */limit?: number; /** Skip query silently when unauthenticated */
   skipUnauth?: boolean; /** Placeholder data shown while loading (item array, not pagination result) */
   placeholderData?: ExtractPaginatedItem<FunctionReturnType<T>>[];
 } & DistributiveOmit<UseQueryOptions<FunctionReturnType<T>, DefaultError>, ReservedInfiniteQueryOptions>;
-/** Metadata for infinite query (extends ConvexQueryMeta) */
-type ConvexInfiniteQueryMeta = ConvexQueryMeta & {
-  /** The query function name (serializable for RSC) */queryName: string; /** Query args without cursor/limit (user's filter args only) */
-  args: Record<string, unknown>; /** Items per page (optional - server uses .paginated() default) */
-  limit?: number;
-};
 /** Return type of infiniteQueryOptions - compatible with TanStack prefetch */
 type ConvexInfiniteQueryOptions<T extends FunctionReference<'query'>> = Pick<UseQueryOptions<FunctionReturnType<T>, Error, FunctionReturnType<T>, ConvexQueryKey<T>>, 'queryKey' | 'staleTime' | 'enabled'> & {
   meta: ConvexInfiniteQueryMeta;
@@ -656,8 +678,6 @@ type DecorateInfiniteQuery<T extends FunctionReference<'query'>> = {
   infiniteQueryKey: (args?: DeepPartial<InfiniteQueryInput<FunctionArgs<T>>>) => ConvexQueryKey<T>; /** Function metadata from server (auth, limit, rateLimit, role, type) */
   meta: PaginatedFnMeta;
 };
-/** Mutation variables type - undefined when no args required (allows mutateAsync() without args) */
-type MutationVariables<T extends FunctionReference<'mutation' | 'action'>> = keyof FunctionArgs<T> extends never ? void : EmptyObject extends FunctionArgs<T> ? FunctionArgs<T> | undefined : FunctionArgs<T>;
 /**
  * Decorated mutation procedure with mutationOptions and mutationKey methods.
  */
@@ -689,54 +709,16 @@ type VanillaQuery<T extends FunctionReference<'query'>> = {
   query: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
   watchQuery: keyof FunctionArgs<T> extends never ? (args?: EmptyObject, opts?: WatchQueryOptions) => Watch<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>, opts?: WatchQueryOptions) => Watch<FunctionReturnType<T>> : (args: FunctionArgs<T>, opts?: WatchQueryOptions) => Watch<FunctionReturnType<T>>;
 };
-/** Vanilla mutation - direct .mutate() call without React Query */
-type VanillaMutation<T extends FunctionReference<'mutation'>> = {
-  mutate: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
-};
-/** Vanilla action - both .query() and .mutate() for direct calls */
-type VanillaAction<T extends FunctionReference<'action'>> = {
-  query: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
-  mutate: keyof FunctionArgs<T> extends never ? (args?: EmptyObject) => Promise<FunctionReturnType<T>> : EmptyObject extends FunctionArgs<T> ? (args?: FunctionArgs<T>) => Promise<FunctionReturnType<T>> : (args: FunctionArgs<T>) => Promise<FunctionReturnType<T>>;
-};
 /**
  * Recursively creates vanilla client type for direct procedural calls.
- * Similar to CRPCClient but for imperative usage outside React Query.
- *
- * @example
- * ```ts
- * const client = useCRPCClient();
- * await client.user.get.query({ id });
- * await client.user.update.mutate({ id, name: 'test' });
- * ```
  */
 type VanillaCRPCClient<TApi> = { [K in keyof TApi as K extends string ? K extends `_${string}` ? never : K : K]: TApi[K] extends FunctionReference<'query'> ? VanillaQuery<TApi[K]> : TApi[K] extends FunctionReference<'mutation'> ? VanillaMutation<TApi[K]> : TApi[K] extends FunctionReference<'action'> ? VanillaAction<TApi[K]> : TApi[K] extends Record<string, unknown> ? VanillaCRPCClient<TApi[K]> : never };
 /**
  * Recursively decorates all procedures in a Convex API object.
- *
- * - Queries get `queryOptions(args, opts?)`
- * - Paginated queries also get `infiniteQueryOptions(args, opts)`
- * - Mutations get `mutationOptions(opts?)`
- * - Actions get `mutationOptions(opts?)`
- * - Nested objects are recursively decorated
- *
- * @example
- * ```ts
- * type Client = CRPCClient<typeof api>;
- * // Client.user.get.queryOptions({ id }) -> QueryOptions
- * // Client.posts.list.infiniteQueryOptions({ userId }, { initialNumItems: 20 }) -> InfiniteQueryOptions
- * // Client.user.update.mutationOptions() -> MutationOptions
- * ```
  */
-/** Check if a type has cursor key (pagination detection) */
-type IsPaginated<T> = 'cursor' extends keyof T ? true : false;
 type CRPCClient<TApi> = { [K in keyof TApi as K extends string ? K extends `_${string}` ? never : K : K]: TApi[K] extends FunctionReference<'query'> ? IsPaginated<FunctionArgs<TApi[K]>> extends true ? DecorateQuery<TApi[K]> & DecorateInfiniteQuery<TApi[K]> : DecorateQuery<TApi[K]> : TApi[K] extends FunctionReference<'mutation'> ? DecorateMutation<TApi[K]> : TApi[K] extends FunctionReference<'action'> ? DecorateAction<TApi[K]> : TApi[K] extends Record<string, unknown> ? CRPCClient<TApi[K]> : never };
 //#endregion
-//#region src/react/http-proxy.d.ts
-type HttpRouteInfo = {
-  path: string;
-  method: string;
-};
-type HttpRouteMap = Record<string, HttpRouteInfo>;
+//#region src/crpc/http-client.d.ts
 /** Form value types (matches Hono's FormValue) */
 type HttpFormValue = string | Blob;
 /**
@@ -770,6 +752,13 @@ type HttpClientOptions = {
   init?: RequestInit; /** Additional headers (or async function returning headers) */
   headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
 };
+//#endregion
+//#region src/react/http-proxy.d.ts
+type HttpRouteInfo = {
+  path: string;
+  method: string;
+};
+type HttpRouteMap = Record<string, HttpRouteInfo>;
 /** Infer schema type or return empty object if UnsetMarker */
 type InferSchemaOrEmpty<T> = T extends UnsetMarker ? object : T extends z.ZodTypeAny ? z.infer<T> : object;
 /** Infer merged input from HttpProcedure (flat - used internally) */
@@ -1260,4 +1249,4 @@ declare function useUploadMutationOptions<TGenerateUrlMutation extends FunctionR
  */
 declare function createVanillaCRPCProxy<TApi extends Record<string, unknown>>(api: TApi, meta: CallerMeta, convexClient: ConvexReactClient$1, transformer?: DataTransformerOptions): VanillaCRPCClient<TApi>;
 //#endregion
-export { AuthMutationError, AuthProvider, AuthStore, AuthStoreState, Authenticated, CRPCHttpOptions, ConvexAuthBridge, ConvexProvider, ConvexProviderWithAuth, ConvexQueryClient, ConvexQueryClientOptions, ConvexQueryClientSingletonOptions, ConvexReactClient, CreateCRPCContextOptions, FetchAccessTokenContext, FetchAccessTokenFn, HttpCRPCClient, HttpCRPCClientFromRouter, HttpClientOptions, HttpFormValue, HttpInputArgs, HttpMutationKey, HttpProxyOptions, HttpQueryKey, HttpRouteInfo, HttpRouteMap, MaybeAuthenticated, MaybeUnauthenticated, PaginationState, PaginationStatus, Unauthenticated, UseInfiniteQueryResult, VanillaHttpCRPCClient, VanillaHttpCRPCClientFromRouter, createAuthMutations, createCRPCContext, createCRPCOptionsProxy, createHttpProxy, createVanillaCRPCProxy, decodeJwtExp, getConvexQueryClientSingleton, getQueryClientSingleton, isAuthMutationError, useAuth, useAuthGuard, useAuthState, useAuthStore, useAuthValue, useConvex, useConvexActionOptions, useConvexActionQueryOptions, useSafeConvexAuth as useConvexAuth, useSafeConvexAuth, useConvexAuthBridge, useConvexInfiniteQueryOptions, useConvexMutationOptions, useConvexQueryClient, useConvexQueryOptions, useFetchAccessToken, useFnMeta, useInfiniteQuery, useIsAuth, useMaybeAuth, useMeta, useUploadMutationOptions };
+export { AuthMutationError, AuthProvider, AuthStore, AuthStoreState, Authenticated, CRPCHttpOptions, ConvexAuthBridge, ConvexProvider, ConvexProviderWithAuth, ConvexQueryClient, ConvexQueryClientOptions, ConvexQueryClientSingletonOptions, ConvexReactClient, CreateCRPCContextOptions, FetchAccessTokenContext, FetchAccessTokenFn, HttpCRPCClient, HttpCRPCClientFromRouter, type HttpClientOptions, type HttpFormValue, type HttpInputArgs, HttpMutationKey, HttpProxyOptions, HttpQueryKey, HttpRouteInfo, HttpRouteMap, MaybeAuthenticated, MaybeUnauthenticated, PaginationState, PaginationStatus, Unauthenticated, UseInfiniteQueryResult, VanillaHttpCRPCClient, VanillaHttpCRPCClientFromRouter, createAuthMutations, createCRPCContext, createCRPCOptionsProxy, createHttpProxy, createVanillaCRPCProxy, decodeJwtExp, getConvexQueryClientSingleton, getQueryClientSingleton, isAuthMutationError, useAuth, useAuthGuard, useAuthState, useAuthStore, useAuthValue, useConvex, useConvexActionOptions, useConvexActionQueryOptions, useSafeConvexAuth as useConvexAuth, useSafeConvexAuth, useConvexAuthBridge, useConvexInfiniteQueryOptions, useConvexMutationOptions, useConvexQueryClient, useConvexQueryOptions, useFetchAccessToken, useFnMeta, useInfiniteQuery, useIsAuth, useMaybeAuth, useMeta, useUploadMutationOptions };