kitcn 0.0.1 → 0.12.1

package/dist/solid/index.js

@@ -0,0 +1,2940 @@
+import { getFunctionName } from "convex/server";
+import { Show, createContext, createEffect, createMemo, createSignal, on, onCleanup, onMount, useContext } from "solid-js";
+import { createComponent, memo } from "solid-js/web";
+import { createStore } from "solid-js/store";
+import { notifyManager, skipToken, useQueries, useQueryClient } from "@tanstack/solid-query";
+import { ConvexClient, ConvexHttpClient } from "convex/browser";
+import { hashKey } from "@tanstack/query-core";
+import { convexToJson } from "convex/values";
+
+//#region src/crpc/error.ts
+/**
+* Client-side CRPC error.
+* Mirrors backend CRPCError pattern with typed error codes.
+*/
+var CRPCClientError = class extends Error {
+	name = "CRPCClientError";
+	code;
+	functionName;
+	constructor(opts) {
+		super(opts.message ?? `${opts.code}: ${opts.functionName}`);
+		this.code = opts.code;
+		this.functionName = opts.functionName;
+	}
+};
+/** Type guard for CRPCClientError */
+const isCRPCClientError = (error) => error instanceof CRPCClientError;
+/** Default unauthorized detection - checks UNAUTHORIZED code */
+const defaultIsUnauthorized = (error) => {
+	if (!error || typeof error !== "object") return false;
+	if ("data" in error) {
+		const data = error.data;
+		if (data && typeof data === "object" && "code" in data) return data.code === "UNAUTHORIZED";
+	}
+	if ("code" in error) return error.code === "UNAUTHORIZED";
+	return false;
+};
+
+//#endregion
+//#region src/solid/auth-store.tsx
+/** @jsxImportSource solid-js */
+/**
+* Auth Store - Generic auth state management with Solid stores
+*
+* Provides token storage and auth callback configuration.
+* App configures handlers, lib hooks consume state.
+*/
+const FetchAccessTokenContext = createContext(null);
+/** Get fetchAccessToken from context (available immediately, no race condition) */
+const useFetchAccessToken = () => useContext(FetchAccessTokenContext);
+/**
+* Context that holds auth result from ConvexAuthBridge.
+* Allows @convex-dev/auth users to use skipUnauth queries without better-auth.
+*/
+const ConvexAuthBridgeContext = createContext(null);
+/** Get auth from bridge context (null if no bridge configured) */
+const useConvexAuthBridge = () => useContext(ConvexAuthBridgeContext);
+/** Decode JWT expiration (ms timestamp) from token */
+function decodeJwtExp(token) {
+	try {
+		const payload = JSON.parse(atob(token.split(".")[1]));
+		return payload.exp ? payload.exp * 1e3 : null;
+	} catch {
+		return null;
+	}
+}
+const defaultState = {
+	onMutationUnauthorized: () => {
+		throw new CRPCClientError({
+			code: "UNAUTHORIZED",
+			functionName: "mutation"
+		});
+	},
+	onQueryUnauthorized: () => {},
+	isUnauthorized: defaultIsUnauthorized,
+	token: null,
+	expiresAt: null,
+	isLoading: true,
+	isAuthenticated: false
+};
+const AuthStoreContext = createContext(null);
+function useAuthStore() {
+	const ctx = useContext(AuthStoreContext);
+	if (!ctx) return {
+		get: (key) => defaultState[key],
+		set: () => {},
+		store: null
+	};
+	return ctx;
+}
+function useAuthValue(key) {
+	return useAuthStore().get(key);
+}
+function AuthProvider(props) {
+	const [state, setState] = createStore({
+		...defaultState,
+		...props.initialValues,
+		...props.isUnauthorized && { isUnauthorized: props.isUnauthorized },
+		...props.onMutationUnauthorized && { onMutationUnauthorized: props.onMutationUnauthorized },
+		...props.onQueryUnauthorized && { onQueryUnauthorized: props.onQueryUnauthorized }
+	});
+	const store = {
+		get: (key) => state[key],
+		set: (key, value) => setState(key, value),
+		store: state
+	};
+	return createComponent(AuthStoreContext.Provider, {
+		value: store,
+		get children() {
+			return props.children;
+		}
+	});
+}
+/**
+* Safe wrapper that doesn't throw when used outside auth provider.
+* Returns { isAuthenticated: false, isLoading: false } when no auth provider.
+*
+* Supports both:
+* - better-auth users (via AuthProvider)
+* - @convex-dev/auth users (via ConvexAuthBridge)
+*/
+function useSafeConvexAuth() {
+	const authStore = useAuthStore();
+	const bridgeAuth = useConvexAuthBridge();
+	return {
+		get isAuthenticated() {
+			if (authStore.store) return authStore.get("isAuthenticated");
+			if (bridgeAuth !== null) return bridgeAuth.isAuthenticated;
+			return false;
+		},
+		get isLoading() {
+			if (authStore.store) return authStore.get("isLoading");
+			if (bridgeAuth !== null) return bridgeAuth.isLoading;
+			return false;
+		}
+	};
+}
+/**
+* Bridge component that provides auth state via context.
+* @internal
+*/
+function ConvexAuthBridge(props) {
+	return createComponent(ConvexAuthBridgeContext.Provider, {
+		value: {
+			get isLoading() {
+				return props.isLoading;
+			},
+			get isAuthenticated() {
+				return props.isAuthenticated;
+			}
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+const useAuth = () => {
+	const authStore = useAuthStore();
+	const bridgeAuth = useConvexAuthBridge();
+	return {
+		get hasSession() {
+			if (authStore.store) return !!authStore.get("token");
+			return false;
+		},
+		get isAuthenticated() {
+			if (authStore.store) return authStore.get("isAuthenticated");
+			if (bridgeAuth !== null) return bridgeAuth.isAuthenticated;
+			return false;
+		},
+		get isLoading() {
+			if (authStore.store) return authStore.get("isLoading");
+			if (bridgeAuth !== null) return bridgeAuth.isLoading;
+			return false;
+		}
+	};
+};
+/** Check if user maybe has auth (optimistic, has token) */
+const useMaybeAuth = () => {
+	const auth = useAuth();
+	return () => auth.hasSession;
+};
+/** Check if user is authenticated (server-verified) */
+const useIsAuth = () => {
+	const auth = useAuth();
+	return () => auth.isAuthenticated;
+};
+const useAuthGuard = () => {
+	const authStore = useAuthStore();
+	const bridgeAuth = useConvexAuthBridge();
+	return (callback) => {
+		let isAuthenticated = false;
+		if (authStore.store) isAuthenticated = authStore.get("isAuthenticated");
+		else if (bridgeAuth !== null) isAuthenticated = bridgeAuth.isAuthenticated;
+		if (!isAuthenticated) {
+			authStore.get("onMutationUnauthorized")();
+			return true;
+		}
+		return callback ? void callback() : false;
+	};
+};
+/** Render children only when maybe has auth (optimistic) */
+function MaybeAuthenticated(props) {
+	const isAuth = useMaybeAuth();
+	return createComponent(Show, {
+		get when() {
+			return isAuth();
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+/** Render children only when authenticated (server-verified) */
+function Authenticated(props) {
+	const isAuth = useIsAuth();
+	return createComponent(Show, {
+		get when() {
+			return isAuth();
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+/** Render children only when maybe not auth (optimistic) */
+function MaybeUnauthenticated(props) {
+	const isAuth = useMaybeAuth();
+	return createComponent(Show, {
+		get when() {
+			return !isAuth();
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+/** Render children only when not authenticated (server-verified) */
+function Unauthenticated(props) {
+	const auth = useAuth();
+	return createComponent(Show, {
+		get when() {
+			return memo(() => !!!auth.isAuthenticated)() && !auth.isLoading;
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+
+//#endregion
+//#region src/solid/auth.ts
+const MetaContext = createContext(void 0);
+/**
+* Hook to access the meta object from context.
+* Returns undefined if meta was not provided.
+*/
+function useMeta() {
+	return useContext(MetaContext);
+}
+/**
+* Hook to get function metadata from the meta index.
+*/
+function useFnMeta() {
+	const meta = useMeta();
+	return (namespace, fnName) => meta?.[namespace]?.[fnName];
+}
+/** Get auth type from meta for a function */
+function getAuthType(meta, funcName) {
+	const [namespace, fnName] = funcName.split(":");
+	return meta?.[namespace]?.[fnName]?.auth;
+}
+/** Hook to compute auth-based skip logic for queries */
+function useAuthSkip(funcRef, opts) {
+	const auth = useSafeConvexAuth();
+	const authType = getAuthType(useMeta(), getFunctionName(funcRef));
+	const authLoadingApplies = authType === "optional" || authType === "required";
+	return {
+		authType,
+		get isAuthLoading() {
+			return auth.isLoading;
+		},
+		get isAuthenticated() {
+			return auth.isAuthenticated;
+		},
+		get shouldSkip() {
+			const isAuthLoading = auth.isLoading;
+			const isAuthenticated = auth.isAuthenticated;
+			return opts?.enabled === false || authLoadingApplies && isAuthLoading || authType === "required" && !isAuthenticated && !isAuthLoading || !isAuthenticated && !isAuthLoading && !!opts?.skipUnauth;
+		}
+	};
+}
+
+//#endregion
+//#region src/shared/meta-utils.ts
+const metaCache = /* @__PURE__ */ new WeakMap();
+const nonMetaLeafKeys = new Set(["functionRef", "ref"]);
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isFunctionType(value) {
+	return value === "query" || value === "mutation" || value === "action";
+}
+function isMetaScalar(value) {
+	return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function extractLeafMeta(value) {
+	const type = value.type;
+	if (!isFunctionType(type)) return;
+	const result = { type };
+	for (const [key, entry] of Object.entries(value)) {
+		if (key === "type" || nonMetaLeafKeys.has(key) || key.startsWith("_")) continue;
+		if (entry === void 0) continue;
+		if (isMetaScalar(entry)) result[key] = entry;
+	}
+	return result;
+}
+function getHttpRoutes(api) {
+	const routes = api._http;
+	if (!isRecord(routes)) return;
+	const normalized = {};
+	for (const [routeKey, routeValue] of Object.entries(routes)) {
+		if (!isRecord(routeValue)) continue;
+		const routePath = routeValue.path;
+		const routeMethod = routeValue.method;
+		if (typeof routePath === "string" && typeof routeMethod === "string") normalized[routeKey] = {
+			path: routePath,
+			method: routeMethod
+		};
+	}
+	return normalized;
+}
+/**
+* Build a metadata index from merged API leaves.
+* Supports both generated `api` objects and plain metadata fixtures.
+*/
+function buildMetaIndex(api) {
+	const cached = metaCache.get(api);
+	if (cached) return cached;
+	const meta = {};
+	const httpRoutes = getHttpRoutes(api);
+	if (httpRoutes) meta._http = httpRoutes;
+	const walk = (node, path) => {
+		for (const [key, value] of Object.entries(node)) {
+			if (key.startsWith("_")) continue;
+			if (!isRecord(value)) continue;
+			const leafMeta = extractLeafMeta(value);
+			if (leafMeta) {
+				if (path.length === 0) continue;
+				const namespace = path.join("/");
+				meta[namespace] ??= {};
+				meta[namespace][key] = leafMeta;
+				continue;
+			}
+			walk(value, [...path, key]);
+		}
+	};
+	walk(api, []);
+	metaCache.set(api, meta);
+	return meta;
+}
+/**
+* Get a function reference from the API object by traversing the path.
+*/
+function getFuncRef(api, path) {
+	let current = api;
+	for (const key of path) if (current && typeof current === "object") {
+		const next = current[key];
+		if (next === void 0) throw new Error(`Invalid path: ${path.join(".")}`);
+		current = next;
+	} else throw new Error(`Invalid path: ${path.join(".")}`);
+	if (current && typeof current === "object") {
+		const maybeFunctionRef = current.functionRef;
+		if (maybeFunctionRef && typeof maybeFunctionRef === "object") return maybeFunctionRef;
+	}
+	if (!current || typeof current !== "object") throw new Error(`Invalid function reference at path: ${path.join(".")}`);
+	return current;
+}
+/**
+* Get function type from meta using path.
+* Supports nested paths like ['items', 'queries', 'list'] → namespace='items/queries', fn='list'
+*
+* @param path - Path segments like ['todos', 'create'] or ['items', 'queries', 'list']
+* @param meta - The meta object from codegen
+* @returns Function type or 'query' as default
+*/
+function getFunctionType(path, source) {
+	if (path.length < 2) return "query";
+	const meta = buildMetaIndex(source);
+	const fnName = path.at(-1);
+	const fnType = meta[path.slice(0, -1).join("/")]?.[fnName]?.type;
+	if (fnType === "query" || fnType === "mutation" || fnType === "action") return fnType;
+	return "query";
+}
+/**
+* Get function metadata from meta using path.
+* Supports nested paths like ['items', 'queries', 'list'] → namespace='items/queries', fn='list'
+*
+* @param path - Path segments like ['todos', 'create'] or ['items', 'queries', 'list']
+* @param meta - The meta object from codegen
+* @returns Function metadata or undefined
+*/
+function getFunctionMeta(path, source) {
+	if (path.length < 2) return;
+	const meta = buildMetaIndex(source);
+	const fnName = path.at(-1);
+	return meta[path.slice(0, -1).join("/")]?.[fnName];
+}
+
+//#endregion
+//#region src/crpc/http-types.ts
+/** HTTP client error */
+var HttpClientError = class extends Error {
+	name = "HttpClientError";
+	code;
+	status;
+	procedureName;
+	constructor(opts) {
+		super(opts.message ?? `${opts.code}: ${opts.procedureName}`);
+		this.code = opts.code;
+		this.status = opts.status;
+		this.procedureName = opts.procedureName;
+	}
+};
+
+//#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/transformer.ts
+const isPlainObject = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+const CODEC_MARKER_KEY = "__crpc";
+const CODEC_MARKER_VALUE = 1;
+const CODEC_TAG_KEY = "t";
+const CODEC_VALUE_KEY = "v";
+const hasOnlyCodecPayloadKeys = (value) => {
+	let keyCount = 0;
+	for (const key in value) {
+		if (!Object.hasOwn(value, key)) continue;
+		keyCount += 1;
+		if (key !== CODEC_MARKER_KEY && key !== CODEC_TAG_KEY && key !== CODEC_VALUE_KEY) return false;
+		if (keyCount > 3) return false;
+	}
+	return keyCount === 3;
+};
+/**
+* Date wire tag (Convex-style reserved key).
+*/
+const DATE_CODEC_TAG = "$date";
+/**
+* Built-in Date codec.
+*/
+const dateWireCodec = {
+	tag: DATE_CODEC_TAG,
+	isType: (value) => value instanceof Date,
+	encode: (value) => value.getTime(),
+	decode: (value) => {
+		if (typeof value !== "number") return value;
+		return new Date(value);
+	}
+};
+/**
+* Build a recursive tagged transformer from codecs.
+*/
+const createTaggedTransformer = (codecs) => {
+	const codecByTag = /* @__PURE__ */ new Map();
+	for (const codec of codecs) {
+		if (!codec.tag.startsWith("$")) throw new Error(`Invalid wire codec tag '${codec.tag}'. Tags must start with '$'.`);
+		if (codecByTag.has(codec.tag)) throw new Error(`Duplicate wire codec tag '${codec.tag}'.`);
+		codecByTag.set(codec.tag, codec);
+	}
+	const serialize = (value) => {
+		for (const codec of codecs) if (codec.isType(value)) return {
+			[CODEC_MARKER_KEY]: CODEC_MARKER_VALUE,
+			[CODEC_TAG_KEY]: codec.tag,
+			[CODEC_VALUE_KEY]: serialize(codec.encode(value))
+		};
+		if (Array.isArray(value)) {
+			let result;
+			for (let index = 0; index < value.length; index += 1) {
+				const item = value[index];
+				const serialized = serialize(item);
+				if (serialized !== item) {
+					if (!result) result = value.slice();
+					result[index] = serialized;
+				}
+			}
+			return result ?? value;
+		}
+		if (isPlainObject(value)) {
+			let result;
+			for (const key in value) {
+				if (!Object.hasOwn(value, key)) continue;
+				const nested = value[key];
+				const serialized = serialize(nested);
+				if (serialized !== nested) {
+					if (!result) result = { ...value };
+					result[key] = serialized;
+				}
+			}
+			return result ?? value;
+		}
+		return value;
+	};
+	const deserialize = (value) => {
+		if (Array.isArray(value)) {
+			let result;
+			for (let index = 0; index < value.length; index += 1) {
+				const item = value[index];
+				const deserialized = deserialize(item);
+				if (deserialized !== item) {
+					if (!result) result = value.slice();
+					result[index] = deserialized;
+				}
+			}
+			return result ?? value;
+		}
+		if (isPlainObject(value)) {
+			const marker = value[CODEC_MARKER_KEY];
+			const tag = value[CODEC_TAG_KEY];
+			if (marker === CODEC_MARKER_VALUE && typeof tag === "string" && CODEC_VALUE_KEY in value && hasOnlyCodecPayloadKeys(value)) {
+				const codec = codecByTag.get(tag);
+				if (codec) return codec.decode(deserialize(value[CODEC_VALUE_KEY]));
+			}
+			let result;
+			for (const key in value) {
+				if (!Object.hasOwn(value, key)) continue;
+				const nested = value[key];
+				const deserialized = deserialize(nested);
+				if (deserialized !== nested) {
+					if (!result) result = { ...value };
+					result[key] = deserialized;
+				}
+			}
+			return result ?? value;
+		}
+		return value;
+	};
+	return {
+		serialize,
+		deserialize
+	};
+};
+/**
+* Default cRPC transformer (Date-enabled).
+*/
+const defaultCRPCTransformer = createTaggedTransformer([dateWireCodec]);
+const DEFAULT_COMBINED_TRANSFORMER = {
+	input: defaultCRPCTransformer,
+	output: defaultCRPCTransformer
+};
+/**
+* Normalize transformer config to split input/output shape.
+*/
+const normalizeCustomTransformer = (transformer) => {
+	if (!transformer) return;
+	if ("input" in transformer && "output" in transformer) return transformer;
+	return {
+		input: transformer,
+		output: transformer
+	};
+};
+/**
+* Compose user transformer with default Date transformer.
+*
+* Date transformer is always active:
+* - serialize: user -> default(Date)
+* - deserialize: default(Date) -> user
+*/
+const composeWithDefault = (transformer) => {
+	if (!transformer) return defaultCRPCTransformer;
+	return {
+		serialize: (value) => defaultCRPCTransformer.serialize(transformer.serialize(value)),
+		deserialize: (value) => transformer.deserialize(defaultCRPCTransformer.deserialize(value))
+	};
+};
+const transformerCache = /* @__PURE__ */ new WeakMap();
+/**
+* Normalize transformer config to split input/output shape.
+* User transformers are additive and always composed with default Date handling.
+*/
+const getTransformer = (transformer) => {
+	if (!transformer) return DEFAULT_COMBINED_TRANSFORMER;
+	const cacheKey = transformer;
+	const cached = transformerCache.get(cacheKey);
+	if (cached) return cached;
+	const custom = normalizeCustomTransformer(transformer);
+	const resolved = {
+		input: composeWithDefault(custom?.input),
+		output: composeWithDefault(custom?.output)
+	};
+	transformerCache.set(cacheKey, resolved);
+	return resolved;
+};
+
+//#endregion
+//#region src/solid/http-proxy.ts
+/**
+* Create a recursive proxy for HTTP routes with TanStack Query integration.
+*
+* Terminal methods:
+* - GET endpoints: `queryOptions`, `queryKey`
+* - POST/PUT/PATCH/DELETE: `mutationOptions`, `mutationKey`
+*/
+function createRecursiveHttpProxy(opts, path = []) {
+	return new Proxy(() => {}, { get(_, prop) {
+		if (typeof prop === "symbol") return;
+		if (prop === "then") return;
+		const routeKey = path.join(".");
+		const route = opts.routes[routeKey];
+		if (prop === "query") {
+			if (!route) throw new Error(`Unknown HTTP procedure: ${routeKey}`);
+			return async (args) => {
+				try {
+					return await executeHttpRequest({
+						convexSiteUrl: opts.convexSiteUrl,
+						route,
+						procedureName: routeKey,
+						args,
+						baseHeaders: opts.headers,
+						baseFetch: opts.fetch,
+						transformer: opts.transformer
+					});
+				} catch (error) {
+					if (opts.onError && error instanceof HttpClientError) opts.onError(error);
+					throw error;
+				}
+			};
+		}
+		if (prop === "mutate") {
+			if (!route) throw new Error(`Unknown HTTP procedure: ${routeKey}`);
+			return async (args) => {
+				try {
+					return await executeHttpRequest({
+						convexSiteUrl: opts.convexSiteUrl,
+						route,
+						procedureName: routeKey,
+						args,
+						baseHeaders: opts.headers,
+						baseFetch: opts.fetch,
+						transformer: opts.transformer
+					});
+				} catch (error) {
+					if (opts.onError && error instanceof HttpClientError) opts.onError(error);
+					throw error;
+				}
+			};
+		}
+		if (prop === "queryOptions") {
+			if (!route) throw new Error(`Unknown HTTP procedure: ${routeKey}`);
+			if (route.method !== "GET") throw new Error(`queryOptions is only available for GET endpoints, got ${route.method} for ${routeKey}`);
+			return (args, queryOpts) => ({
+				...queryOpts,
+				queryKey: [
+					"httpQuery",
+					routeKey,
+					args
+				],
+				queryFn: async () => {
+					try {
+						return await executeHttpRequest({
+							convexSiteUrl: opts.convexSiteUrl,
+							route,
+							procedureName: routeKey,
+							args,
+							baseHeaders: opts.headers,
+							baseFetch: opts.fetch,
+							transformer: opts.transformer
+						});
+					} catch (error) {
+						if (opts.onError && error instanceof HttpClientError) opts.onError(error);
+						throw error;
+					}
+				}
+			});
+		}
+		if (prop === "queryKey") return (args) => {
+			return args !== void 0 && !(typeof args === "object" && args !== null && Object.keys(args).length === 0) ? [
+				"httpQuery",
+				routeKey,
+				args
+			] : ["httpQuery", routeKey];
+		};
+		if (prop === "queryFilter") return (args, filters) => {
+			const hasArgs = args !== void 0 && !(typeof args === "object" && args !== null && Object.keys(args).length === 0);
+			return {
+				...filters,
+				queryKey: hasArgs ? [
+					"httpQuery",
+					routeKey,
+					args
+				] : ["httpQuery", routeKey]
+			};
+		};
+		if (prop === "mutationOptions") {
+			if (!route) throw new Error(`Unknown HTTP procedure: ${routeKey}`);
+			return (mutationOpts) => ({
+				...mutationOpts,
+				mutationKey: ["httpMutation", routeKey],
+				mutationFn: async (args) => {
+					try {
+						return await executeHttpRequest({
+							convexSiteUrl: opts.convexSiteUrl,
+							route,
+							procedureName: routeKey,
+							args,
+							baseHeaders: opts.headers,
+							baseFetch: opts.fetch,
+							transformer: opts.transformer
+						});
+					} catch (error) {
+						if (opts.onError && error instanceof HttpClientError) opts.onError(error);
+						throw error;
+					}
+				}
+			});
+		}
+		if (prop === "mutationKey") return () => ["httpMutation", routeKey];
+		return createRecursiveHttpProxy(opts, [...path, prop]);
+	} });
+}
+/**
+* Create an HTTP proxy with TanStack Query integration for SolidJS.
+*
+* Returns a proxy that provides:
+* - `queryOptions` for GET endpoints (no subscription)
+* - `mutationOptions` for POST/PUT/PATCH/DELETE endpoints
+*
+* @example
+* ```ts
+* const httpProxy = createHttpProxy<AppRouter>({
+*   convexSiteUrl: import.meta.env.VITE_CONVEX_SITE_URL,
+*   routes: httpRoutes,
+* });
+*
+* // GET endpoint
+* const opts = httpProxy.todos.get.queryOptions({ id: '123' });
+* const query = createQuery(() => opts);
+*
+* // POST endpoint
+* const mutation = createMutation(() => httpProxy.todos.create.mutationOptions());
+* await mutation.mutateAsync({ title: 'New todo' });
+* ```
+*/
+function createHttpProxy(opts) {
+	const transformer = getTransformer(opts.transformer);
+	return createRecursiveHttpProxy({
+		convexSiteUrl: opts.convexSiteUrl,
+		routes: opts.routes,
+		headers: opts.headers,
+		fetch: opts.fetch,
+		onError: opts.onError,
+		transformer
+	});
+}
+
+//#endregion
+//#region src/crpc/query-options.ts
+/**
+* Query options factory for Convex query function subscriptions.
+* Requires `convexQueryClient.queryFn()` set as the default `queryFn` globally.
+*/
+function convexQuery(funcRef, args, meta, opts) {
+	const finalArgs = args ?? {};
+	const isSkip = finalArgs === "skip";
+	const funcName = getFunctionName(funcRef);
+	const [namespace, fnName] = funcName.split(":");
+	const authType = meta?.[namespace]?.[fnName]?.auth;
+	const skipUnauth = opts?.skipUnauth;
+	return {
+		queryKey: [
+			"convexQuery",
+			funcName,
+			isSkip ? "skip" : finalArgs
+		],
+		staleTime: Number.POSITIVE_INFINITY,
+		refetchInterval: false,
+		refetchOnMount: false,
+		refetchOnReconnect: false,
+		refetchOnWindowFocus: false,
+		...isSkip ? { enabled: false } : {},
+		meta: {
+			authType,
+			skipUnauth,
+			subscribe: true
+		}
+	};
+}
+/**
+* Query options factory for Convex action functions.
+* Actions are NOT reactive - they follow normal TanStack Query semantics.
+*
+* @example
+* ```ts
+* useQuery(convexAction(api.ai.generate, { prompt }))
+* ```
+*
+* @example With additional options (use spread):
+* ```ts
+* useQuery({
+*   ...convexAction(api.files.process, { fileId }),
+*   staleTime: 60_000
+* });
+* ```
+*/
+function convexAction(funcRef, args, meta, opts) {
+	const finalArgs = args ?? {};
+	const isSkip = finalArgs === "skip";
+	const funcName = getFunctionName(funcRef);
+	const [namespace, fnName] = funcName.split(":");
+	const authType = meta?.[namespace]?.[fnName]?.auth;
+	const skipUnauth = opts?.skipUnauth;
+	return {
+		queryKey: [
+			"convexAction",
+			funcName,
+			isSkip ? {} : finalArgs
+		],
+		staleTime: Number.POSITIVE_INFINITY,
+		refetchInterval: false,
+		refetchOnMount: false,
+		refetchOnReconnect: false,
+		refetchOnWindowFocus: false,
+		...isSkip ? { enabled: false } : {},
+		meta: {
+			authType,
+			skipUnauth,
+			subscribe: false
+		}
+	};
+}
+/**
+* Infinite query options factory for paginated Convex queries.
+* Server-safe (non-hook) - can be used in RSC.
+*
+* Uses flat { cursor, limit } input like tRPC.
+*/
+function convexInfiniteQueryOptions(funcRef, args, opts = {}, meta) {
+	const { limit, skipUnauth, enabled, ...queryOptions } = opts;
+	const finalArgs = args === "skip" ? {} : args;
+	const isSkip = args === "skip";
+	const funcName = getFunctionName(funcRef);
+	const [namespace, fnName] = funcName.split(":");
+	const authType = (meta?.[namespace]?.[fnName])?.auth;
+	const firstPageArgs = {
+		...finalArgs,
+		cursor: null,
+		limit
+	};
+	const finalEnabled = enabled === false || isSkip ? false : void 0;
+	return {
+		queryKey: [
+			"convexQuery",
+			funcName,
+			firstPageArgs
+		],
+		staleTime: Number.POSITIVE_INFINITY,
+		refetchInterval: false,
+		refetchOnMount: false,
+		refetchOnReconnect: false,
+		refetchOnWindowFocus: false,
+		...queryOptions,
+		...finalEnabled === false ? { enabled: false } : {},
+		meta: {
+			authType,
+			skipUnauth,
+			subscribe: true,
+			queryName: funcName,
+			args: finalArgs,
+			limit
+		}
+	};
+}
+
+//#endregion
+//#region src/crpc/types.ts
+/** Symbol key for attaching FunctionReference to options (non-serializable) */
+const FUNC_REF_SYMBOL = Symbol.for("convex.funcRef");
+
+//#endregion
+//#region src/solid/convex-solid.tsx
+/** @jsxImportSource solid-js */
+/**
+* Convex Provider for SolidJS
+*
+* Provides ConvexClient via context and auth integration.
+*/
+const ConvexContext = createContext();
+/** Get the ConvexClient instance from context */
+function useConvex() {
+	const client = useContext(ConvexContext);
+	if (!client) throw new Error("useConvex must be used within a ConvexProvider");
+	return client;
+}
+function ConvexProvider(props) {
+	return createComponent(ConvexContext.Provider, {
+		get value() {
+			return props.client;
+		},
+		get children() {
+			return props.children;
+		}
+	});
+}
+function ConvexProviderWithAuth(props) {
+	const client = props.client;
+	const [isConvexLoading, setIsConvexLoading] = createSignal(true);
+	const [isConvexAuthenticated, setIsConvexAuthenticated] = createSignal(false);
+	createEffect(() => {
+		const auth = props.useAuth();
+		const loading = auth.isLoading;
+		const authenticated = auth.isAuthenticated;
+		if (loading) return;
+		if (!authenticated) {
+			client.clearAuth();
+			setIsConvexLoading(false);
+			setIsConvexAuthenticated(false);
+			return;
+		}
+		client.setAuth(auth.fetchAccessToken, (isAuth) => {
+			setIsConvexLoading(false);
+			setIsConvexAuthenticated(isAuth);
+		});
+	});
+	onCleanup(() => {
+		client.clearAuth();
+	});
+	return createComponent(ConvexContext.Provider, {
+		get value() {
+			return props.client;
+		},
+		get children() {
+			return createComponent(ConvexAuthBridge, {
+				get isAuthenticated() {
+					return isConvexAuthenticated();
+				},
+				get isLoading() {
+					return isConvexLoading();
+				},
+				get children() {
+					return props.children;
+				}
+			});
+		}
+	});
+}
+/** Hook returning auth state from Convex */
+function useConvexAuth() {
+	const bridge = useConvexAuthBridge();
+	if (!bridge) return {
+		isLoading: false,
+		isAuthenticated: false
+	};
+	return bridge;
+}
+
+//#endregion
+//#region src/solid/use-query-options.ts
+/**
+* Query options factories for Convex functions (SolidJS).
+* Port of the React version — uses ConvexClient directly instead of convex/react hooks.
+*
+* Note: In @tanstack/solid-query, UseMutationOptions and UseQueryOptions are
+* Accessor wrappers. We use SolidMutationOptions and SolidQueryOptions (plain
+* object types) for parameters and return values.
+*/
+/**
+* Hook that returns query options for use with useQuery.
+* Handles skipUnauth by setting enabled: false when unauthorized.
+*
+* @example
+* ```tsx
+* const { data } = useQuery(useConvexQueryOptions(api.user.get, { id }));
+* ```
+*
+* @example With skipToken for conditional queries
+* ```tsx
+* const { data } = useQuery(useConvexQueryOptions(api.user.get, userId ? { id: userId } : skipToken));
+* ```
+*
+* @example With skipUnauth
+* ```tsx
+* const { data } = useQuery(useConvexQueryOptions(api.user.get, { id }, { skipUnauth: true }));
+* ```
+*
+* @example With TanStack Query options
+* ```tsx
+* const { data } = useQuery(useConvexQueryOptions(api.user.get, { id }, { enabled: !!id, placeholderData: [] }));
+* ```
+*/
+function useConvexQueryOptions(funcRef, args, options) {
+	const isSkipped = args === skipToken;
+	const enabled = typeof options?.enabled === "function" ? void 0 : options?.enabled;
+	const authSkip = useAuthSkip(funcRef, {
+		enabled: isSkipped ? false : enabled,
+		skipUnauth: options?.skipUnauth
+	});
+	const baseOptions = convexQuery(funcRef, isSkipped ? {} : args);
+	const { skipUnauth: _, subscribe, ...queryOptions } = options ?? {};
+	return {
+		...baseOptions,
+		...queryOptions,
+		enabled: isSkipped ? false : !authSkip.shouldSkip,
+		meta: {
+			...baseOptions.meta,
+			authType: authSkip.authType,
+			subscribe: subscribe !== false
+		}
+	};
+}
+/**
+* Hook that returns infinite query options for use with useInfiniteQuery.
+* Handles auth type detection from meta and skipUnauth.
+*
+* @example
+* ```tsx
+* const { data } = useInfiniteQuery(
+*   useConvexInfiniteQueryOptions(api.posts.list, { userId }, { limit: 20 })
+* );
+* ```
+*
+* @example With skipToken for conditional queries
+* ```tsx
+* const { data } = useInfiniteQuery(
+*   useConvexInfiniteQueryOptions(api.posts.list, userId ? { userId } : skipToken, { limit: 20 })
+* );
+* ```
+*
+* @example With skipUnauth
+* ```tsx
+* const { data } = useInfiniteQuery(
+*   useConvexInfiniteQueryOptions(api.posts.list, { userId }, { limit: 20, skipUnauth: true })
+* );
+* ```
+*/
+function useConvexInfiniteQueryOptions(funcRef, args, opts) {
+	const meta = useMeta();
+	const isSkipped = args === skipToken;
+	const enabledOpt = typeof opts.enabled === "function" ? void 0 : opts.enabled;
+	const authSkip = useAuthSkip(funcRef, {
+		enabled: isSkipped ? false : enabledOpt,
+		skipUnauth: opts.skipUnauth
+	});
+	const enabled = isSkipped || authSkip.shouldSkip ? false : enabledOpt;
+	const baseOptions = convexInfiniteQueryOptions(funcRef, isSkipped ? {} : args, {
+		...opts,
+		enabled
+	}, meta);
+	return {
+		...baseOptions,
+		meta: {
+			...baseOptions.meta,
+			authType: authSkip.authType
+		}
+	};
+}
+/**
+* Hook that returns query options for using an action as a one-shot query.
+* Actions don't support WebSocket subscriptions - they're one-time calls.
+*
+* @example
+* ```tsx
+* const { data } = useQuery(useConvexActionQueryOptions(api.ai.analyze, { id }));
+* ```
+*
+* @example With skipToken for conditional queries
+* ```tsx
+* const { data } = useQuery(useConvexActionQueryOptions(api.ai.analyze, id ? { id } : skipToken));
+* ```
+*
+* @example With skipUnauth
+* ```tsx
+* const { data } = useQuery(useConvexActionQueryOptions(api.ai.analyze, { id }, { skipUnauth: true }));
+* ```
+*/
+function useConvexActionQueryOptions(action, args, options) {
+	const isSkipped = args === skipToken;
+	const enabled = typeof options?.enabled === "function" ? void 0 : options?.enabled;
+	const authSkip = useAuthSkip(action, {
+		enabled: isSkipped ? false : enabled,
+		skipUnauth: options?.skipUnauth
+	});
+	const baseOptions = convexAction(action, isSkipped ? {} : args);
+	const { skipUnauth: _, ...queryOptions } = options ?? {};
+	return {
+		...baseOptions,
+		...queryOptions,
+		enabled: isSkipped ? false : !authSkip.shouldSkip
+	};
+}
+/**
+* Hook that returns mutation options for use with useMutation.
+* Wraps the Convex mutation with auth guard logic.
+*
+* @example
+* ```tsx
+* const { mutate } = useMutation(useConvexMutationOptions(api.user.update));
+* ```
+*
+* @example With TanStack Query options
+* ```tsx
+* const { mutate } = useMutation(useConvexMutationOptions(api.user.update, {
+*   onSuccess: () => toast.success('Updated!'),
+* }));
+* ```
+*/
+function useConvexMutationOptions(mutation, options, transformer) {
+	const guard = useAuthGuard();
+	const getMeta = useFnMeta();
+	const name = getFunctionName(mutation);
+	const [namespace, fnName] = name.split(":");
+	const authType = getMeta(namespace, fnName)?.auth;
+	const convex = useConvex();
+	const resolvedTransformer = getTransformer(transformer);
+	return {
+		...options,
+		mutationFn: async (args) => {
+			if (authType === "required" && guard()) throw new CRPCClientError({
+				code: "UNAUTHORIZED",
+				functionName: name
+			});
+			return convex.mutation(mutation, resolvedTransformer.input.serialize(args));
+		}
+	};
+}
+/**
+* Hook that returns action options for use with useMutation.
+* Wraps the Convex action with auth guard logic.
+*
+* @example
+* ```tsx
+* const { mutate } = useMutation(useConvexActionOptions(api.ai.generate));
+* ```
+*
+* @example With TanStack Query options
+* ```tsx
+* const { mutate } = useMutation(useConvexActionOptions(api.ai.generate, {
+*   onSuccess: (data) => console.info(data),
+* }));
+* ```
+*/
+function useConvexActionOptions(action, options, transformer) {
+	const guard = useAuthGuard();
+	const getMeta = useFnMeta();
+	const name = getFunctionName(action);
+	const [namespace, fnName] = name.split(":");
+	const authType = getMeta(namespace, fnName)?.auth;
+	const convex = useConvex();
+	const resolvedTransformer = getTransformer(transformer);
+	return {
+		...options,
+		mutationFn: async (args) => {
+			if (authType === "required" && guard()) throw new CRPCClientError({
+				code: "UNAUTHORIZED",
+				functionName: name
+			});
+			return convex.action(action, resolvedTransformer.input.serialize(args));
+		}
+	};
+}
+/**
+* Hook that returns upload mutation options for use with useMutation.
+* Generates a presigned URL, then uploads the file directly to storage.
+*
+* @example
+* ```tsx
+* const { mutate } = useMutation(useUploadMutationOptions(api.storage.generateUrl));
+* mutate({ file, ...otherArgs });
+* ```
+*
+* @example With TanStack Query options
+* ```tsx
+* const { mutate } = useMutation(useUploadMutationOptions(api.storage.generateUrl, {
+*   onSuccess: (result) => console.info('Uploaded:', result.key),
+* }));
+* ```
+*/
+function useUploadMutationOptions(generateUrlMutation, options) {
+	const convex = useConvex();
+	return {
+		...options,
+		mutationFn: async ({ file, ...args }) => {
+			const result = await convex.mutation(generateUrlMutation, args);
+			const { url } = result;
+			const response = await fetch(url, {
+				body: file,
+				headers: { "Content-Type": file.type },
+				method: "PUT"
+			});
+			if (!response.ok) throw new Error(`Upload failed: ${response.statusText}`);
+			return result;
+		}
+	};
+}
+
+//#endregion
+//#region src/solid/proxy.ts
+/**
+* CRPC Recursive Proxy
+*
+* Creates a tRPC-like proxy that wraps Convex API functions with
+* TanStack Query options builders.
+*
+* @example
+* ```ts
+* const crpc = createCRPCOptionsProxy(api);
+* const opts = crpc.user.get.queryOptions({ id: '123' });
+* const { data } = useQuery(opts);
+* ```
+*/
+/** Get query key prefix based on function type */
+function getQueryKeyPrefix(path, meta) {
+	if (getFunctionType(path, meta) === "action") return "convexAction";
+	return "convexQuery";
+}
+/**
+* Create a recursive proxy that accumulates path segments.
+*/
+function createRecursiveProxy(api, path, meta, transformer) {
+	return new Proxy(() => {}, { get(_target, prop) {
+		if (typeof prop === "symbol") return;
+		if (prop === "then") return;
+		if (prop === "queryOptions") return (args = {}, opts) => {
+			const funcRef = getFuncRef(api, path);
+			if (getFunctionType(path, meta) === "action") return useConvexActionQueryOptions(funcRef, args, opts);
+			return useConvexQueryOptions(funcRef, args, opts);
+		};
+		if (prop === "staticQueryOptions") return (args = {}, opts) => {
+			const funcRef = getFuncRef(api, path);
+			const fnType = getFunctionType(path, meta);
+			const finalArgs = args === skipToken ? "skip" : args;
+			if (fnType === "action") return convexAction(funcRef, finalArgs, meta, opts);
+			return convexQuery(funcRef, finalArgs, meta, opts);
+		};
+		if (prop === "queryKey") return (args = {}) => {
+			const funcName = getFunctionName(getFuncRef(api, path));
+			return [
+				getQueryKeyPrefix(path, meta),
+				funcName,
+				args
+			];
+		};
+		if (prop === "queryFilter") return (args, filters) => {
+			const funcName = getFunctionName(getFuncRef(api, path));
+			const prefix = getQueryKeyPrefix(path, meta);
+			return {
+				...filters,
+				queryKey: [
+					prefix,
+					funcName,
+					args
+				]
+			};
+		};
+		if (prop === "infiniteQueryOptions") return (args = {}, opts = {}) => {
+			const funcRef = getFuncRef(api, path);
+			const options = useConvexInfiniteQueryOptions(funcRef, args, opts);
+			Object.defineProperty(options, FUNC_REF_SYMBOL, {
+				value: funcRef,
+				enumerable: false,
+				configurable: false
+			});
+			return options;
+		};
+		if (prop === "infiniteQueryKey") return (args) => {
+			return [
+				"convexQuery",
+				getFunctionName(getFuncRef(api, path)),
+				args ?? {}
+			];
+		};
+		if (prop === "meta" && path.length >= 2) return getFunctionMeta(path, meta);
+		if (prop === "mutationKey") return () => {
+			return ["convexMutation", getFunctionName(getFuncRef(api, path))];
+		};
+		if (prop === "mutationOptions") return (opts) => {
+			const funcRef = getFuncRef(api, path);
+			if (getFunctionType(path, meta) === "action") return useConvexActionOptions(funcRef, opts, transformer);
+			return useConvexMutationOptions(funcRef, opts, transformer);
+		};
+		return createRecursiveProxy(api, [...path, prop], meta, transformer);
+	} });
+}
+/**
+* Create a CRPC proxy for a Convex API object.
+*
+* The proxy provides a tRPC-like interface for accessing Convex functions
+* with TanStack Query options builders.
+*
+* @param api - The Convex API object (from `@convex/api`)
+* @param meta - Generated function metadata for runtime type detection
+* @returns A typed proxy with queryOptions/mutationOptions methods
+*
+* @example
+* ```tsx
+* import { api } from '@convex/api';
+*
+* // Usually you should use createCRPCContext({ api }) instead.
+* // createCRPCOptionsProxy is a low-level helper.
+* const crpc = createCRPCOptionsProxy(api, {} as any);
+*
+* function MyComponent() {
+*   const { data } = useQuery(crpc.user.get.queryOptions({ id }));
+*   const { mutate } = useMutation(crpc.user.update.mutationOptions());
+* }
+* ```
+*/
+function createCRPCOptionsProxy(api, meta, transformer) {
+	return createRecursiveProxy(api, [], meta, transformer);
+}
+
+//#endregion
+//#region src/solid/vanilla-client.ts
+/**
+* Create a recursive proxy for vanilla (direct) calls.
+*/
+function createRecursiveVanillaProxy(api, path, meta, convexClient, transformer) {
+	return new Proxy(() => {}, { get(_target, prop) {
+		if (typeof prop === "symbol") return;
+		if (prop === "then") return;
+		if (prop === "query") return async (args = {}) => {
+			const funcRef = getFuncRef(api, path);
+			const fnType = getFunctionType(path, meta);
+			const wireArgs = transformer.input.serialize(args);
+			if (fnType === "action") return transformer.output.deserialize(await convexClient.action(funcRef, wireArgs));
+			return transformer.output.deserialize(await convexClient.query(funcRef, wireArgs));
+		};
+		if (prop === "onUpdate") return (args = {}, callback, onError) => {
+			const funcRef = getFuncRef(api, path);
+			return convexClient.onUpdate(funcRef, transformer.input.serialize(args), callback ? (result) => callback(transformer.output.deserialize(result)) : () => {}, onError);
+		};
+		if (prop === "mutate") return async (args = {}) => {
+			const funcRef = getFuncRef(api, path);
+			const fnType = getFunctionType(path, meta);
+			const wireArgs = transformer.input.serialize(args);
+			if (fnType === "action") return transformer.output.deserialize(await convexClient.action(funcRef, wireArgs));
+			return transformer.output.deserialize(await convexClient.mutation(funcRef, wireArgs));
+		};
+		return createRecursiveVanillaProxy(api, [...path, prop], meta, convexClient, transformer);
+	} });
+}
+/**
+* Create a vanilla CRPC proxy for direct procedural calls.
+*
+* The proxy provides a tRPC-like interface for imperative Convex function calls.
+*
+* @param api - The Convex API object (from `@convex/api`)
+* @param meta - Generated function metadata for runtime type detection
+* @param convexClient - The ConvexClient instance
+* @returns A typed proxy with query/mutate methods
+*
+* @example
+* ```tsx
+* const client = createVanillaCRPCProxy(api, meta, convexClient);
+*
+* // Direct calls (no Solid Query)
+* const user = await client.user.get.query({ id });
+* await client.user.update.mutate({ id, name: 'test' });
+* ```
+*/
+function createVanillaCRPCProxy(api, meta, convexClient, transformer) {
+	return createRecursiveVanillaProxy(api, [], meta, convexClient, getTransformer(transformer));
+}
+
+//#endregion
+//#region src/solid/context.tsx
+/** @jsxImportSource solid-js */
+/**
+* CRPC Context and Provider
+*
+* Provides Solid context for the CRPC proxy, similar to tRPC's createTRPCContext.
+*/
+const ConvexQueryClientContext = createContext(null);
+/** Access ConvexQueryClient (e.g., for logout cleanup) */
+const useConvexQueryClient = () => useContext(ConvexQueryClientContext);
+/** Headers record that allows empty objects and optional properties */
+/**
+* Extract HTTP router from TApi['http'] if present (optional).
+* Uses NonNullable to handle optional http property.
+*/
+/**
+* Create CRPC context, provider, and hooks for a Convex API.
+*
+* @param options - Configuration object containing api and optional HTTP settings
+* @returns Object with CRPCProvider, useCRPC, and useCRPCClient
+*
+* @example
+* ```tsx
+* // lib/crpc.ts
+* import { api } from '@convex/api';
+* import { createCRPCContext } from 'kitcn/solid';
+*
+* // Works for both regular Convex functions and generated HTTP router types
+* export const { useCRPC } = createCRPCContext({
+*   api,
+*   convexSiteUrl: import.meta.env.VITE_CONVEX_SITE_URL,
+* });
+*
+* // components/user-profile.tsx
+* function UserProfile({ id }) {
+*   const crpc = useCRPC();
+*   const { data } = createQuery(() => crpc.user.get.queryOptions({ id }));
+*
+*   // HTTP endpoints (if configured)
+*   const { data: httpData } = createQuery(() => crpc.http.todos.get.queryOptions({ id }));
+* }
+* ```
+*/
+function createCRPCContext(options) {
+	const { api, ...httpOptions } = options;
+	const meta = buildMetaIndex(api);
+	const CRPCProxyContext = createContext(null);
+	const VanillaClientContext = createContext(null);
+	const HttpProxyContext = createContext(void 0);
+	function CRPCProvider(props) {
+		const authStore = useAuthStore();
+		const fetchAccessToken = useFetchAccessToken();
+		const proxy = createCRPCOptionsProxy(api, meta, options.transformer);
+		const vanillaClient = createVanillaCRPCProxy(api, meta, props.convexClient, options.transformer);
+		const httpProxy = (() => {
+			if (!httpOptions.convexSiteUrl || !meta._http) return;
+			return createHttpProxy({
+				convexSiteUrl: httpOptions.convexSiteUrl,
+				routes: meta._http,
+				headers: async () => {
+					const token = authStore.get("token");
+					const expiresAt = authStore.get("expiresAt");
+					const timeRemaining = expiresAt ? expiresAt - Date.now() : 0;
+					if (token && expiresAt && timeRemaining >= 6e4) return {
+						...typeof httpOptions.headers === "function" ? await httpOptions.headers() : httpOptions.headers,
+						Authorization: `Bearer ${token}`
+					};
+					if (fetchAccessToken) {
+						const newToken = await fetchAccessToken({ forceRefreshToken: !!expiresAt });
+						if (newToken) return {
+							...typeof httpOptions.headers === "function" ? await httpOptions.headers() : httpOptions.headers,
+							Authorization: `Bearer ${newToken}`
+						};
+					}
+					return { ...typeof httpOptions.headers === "function" ? await httpOptions.headers() : httpOptions.headers };
+				},
+				fetch: httpOptions.fetch,
+				onError: httpOptions.onError,
+				transformer: options.transformer
+			});
+		})();
+		return createComponent(ConvexQueryClientContext.Provider, {
+			get value() {
+				return props.convexQueryClient;
+			},
+			get children() {
+				return createComponent(MetaContext.Provider, {
+					value: meta,
+					get children() {
+						return createComponent(VanillaClientContext.Provider, {
+							value: vanillaClient,
+							get children() {
+								return createComponent(HttpProxyContext.Provider, {
+									value: httpProxy,
+									get children() {
+										return createComponent(CRPCProxyContext.Provider, {
+											value: proxy,
+											get children() {
+												return props.children;
+											}
+										});
+									}
+								});
+							}
+						});
+					}
+				});
+			}
+		});
+	}
+	function useCRPC() {
+		const ctx = useContext(CRPCProxyContext);
+		const httpProxy = useContext(HttpProxyContext);
+		if (!ctx) throw new Error("useCRPC must be used within CRPCProvider");
+		if (httpProxy) return new Proxy(ctx, { get(target, prop) {
+			if (prop === "http") return httpProxy;
+			return Reflect.get(target, prop);
+		} });
+		return ctx;
+	}
+	function useCRPCClient() {
+		const ctx = useContext(VanillaClientContext);
+		const httpProxy = useContext(HttpProxyContext);
+		if (!ctx) throw new Error("useCRPCClient must be used within CRPCProvider");
+		if (httpProxy) return new Proxy(ctx, { get(target, prop) {
+			if (prop === "http") return httpProxy;
+			return Reflect.get(target, prop);
+		} });
+		return ctx;
+	}
+	return {
+		CRPCProvider,
+		useCRPC,
+		useCRPCClient
+	};
+}
+
+//#endregion
+//#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/solid/auth-mutations.ts
+/** Poll until JWT token exists (auth complete) (max 5s) */
+const waitForAuth = async (store, timeout = 5e3) => {
+	const start = Date.now();
+	while (Date.now() - start < timeout) {
+		if (store.get("token")) return true;
+		await new Promise((r) => setTimeout(r, 50));
+	}
+	return false;
+};
+const authStateTimeoutError = () => new AuthMutationError({
+	code: "AUTH_STATE_TIMEOUT",
+	message: "Authentication did not complete. Try again.",
+	status: 401,
+	statusText: "UNAUTHORIZED"
+});
+const ensureAuth = async (store) => {
+	if (await waitForAuth(store)) return;
+	throw authStateTimeoutError();
+};
+const readReturnedToken = (value) => {
+	if (!value || typeof value !== "object") return null;
+	const record = value;
+	if (typeof record.token === "string" && record.token.length > 0) return record.token;
+	return readReturnedToken(record.data) ?? readReturnedToken(record.session);
+};
+const seedReturnedToken = (store, value) => {
+	const token = readReturnedToken(value);
+	if (!token) return;
+	store.set("token", token);
+	store.set("expiresAt", decodeJwtExp(token));
+};
+/**
+* Create mutation option hooks from a better-auth client.
+*
+* @example
+* ```tsx
+* // lib/auth-client.ts
+* import { createAuthMutations } from 'kitcn/solid';
+*
+* export const authClient = createAuthClient({...});
+*
+* export const {
+*   useSignOutMutationOptions,
+*   useSignInSocialMutationOptions,
+*   useSignInMutationOptions,
+*   useSignUpMutationOptions,
+* } = createAuthMutations(authClient);
+*
+* // components/header.tsx
+* const signOutMutation = createMutation(() => useSignOutMutationOptions({
+*   onSuccess: () => navigate('/login'),
+* }));
+* ```
+*/
+function createAuthMutations(authClient) {
+	const useSignOutMutationOptions = ((options) => {
+		const convexQueryClient = useConvexQueryClient();
+		const authStoreApi = useAuthStore();
+		return {
+			...options,
+			mutationFn: async (args) => {
+				authStoreApi.set("isAuthenticated", false);
+				convexQueryClient?.unsubscribeAuthQueries();
+				const res = await authClient.signOut(args);
+				if (res?.error) throw new AuthMutationError(res.error);
+				authStoreApi.set("token", null);
+				authStoreApi.set("expiresAt", null);
+				return res;
+			}
+		};
+	});
+	const useSignInSocialMutationOptions = ((options) => {
+		const authStoreApi = useAuthStore();
+		return {
+			...options,
+			mutationFn: async (args) => {
+				const res = await authClient.signIn.social(args);
+				if (res?.error) throw new AuthMutationError(res.error);
+				seedReturnedToken(authStoreApi, res);
+				await ensureAuth(authStoreApi);
+				return res;
+			}
+		};
+	});
+	const useSignInMutationOptions = ((options) => {
+		const authStoreApi = useAuthStore();
+		return {
+			...options,
+			mutationFn: async (args) => {
+				const res = await authClient.signIn.email(args);
+				if (res?.error) throw new AuthMutationError(res.error);
+				seedReturnedToken(authStoreApi, res);
+				await ensureAuth(authStoreApi);
+				return res;
+			}
+		};
+	});
+	const useSignUpMutationOptions = ((options) => {
+		const authStoreApi = useAuthStore();
+		return {
+			...options,
+			mutationFn: async (args) => {
+				const res = await authClient.signUp.email(args);
+				if (res?.error) throw new AuthMutationError(res.error);
+				seedReturnedToken(authStoreApi, res);
+				await ensureAuth(authStoreApi);
+				return res;
+			}
+		};
+	});
+	return {
+		useSignOutMutationOptions,
+		useSignInSocialMutationOptions,
+		useSignInMutationOptions,
+		useSignUpMutationOptions
+	};
+}
+
+//#endregion
+//#region src/internal/query-key.ts
+/**
+* Shared query key utilities for Convex + TanStack Query.
+* This file has NO React dependencies so it can be imported in both
+* server (RSC) and client contexts.
+*/
+/**
+* Check if query key is for a Convex query function.
+* Format: ['convexQuery', 'namespace:functionName', { args }]
+*/
+function isConvexQuery(queryKey) {
+	return queryKey.length >= 2 && queryKey[0] === "convexQuery";
+}
+/**
+* Check if query key is for a Convex action function.
+* Format: ['convexAction', 'namespace:functionName', { args }]
+*/
+function isConvexAction$1(queryKey) {
+	return queryKey.length >= 2 && queryKey[0] === "convexAction";
+}
+/**
+* Create stable hash for Convex query keys.
+* Uses Convex's JSON serialization for consistent argument hashing.
+*/
+function hashConvexQuery(queryKey) {
+	const [, funcName, args] = queryKey;
+	return `convexQuery|${funcName}|${JSON.stringify(convexToJson(args))}`;
+}
+/**
+* Create stable hash for Convex action keys.
+* Uses Convex's JSON serialization for consistent argument hashing.
+*/
+function hashConvexAction(queryKey) {
+	const [, funcName, args] = queryKey;
+	return `convexAction|${funcName}|${JSON.stringify(convexToJson(args))}`;
+}
+
+//#endregion
+//#region src/internal/hash.ts
+/**
+* Create a hash function for TanStack Query that handles Convex keys.
+*/
+function createHashFn(fallback = hashKey) {
+	return (queryKey) => {
+		if (isConvexQuery(queryKey)) return hashConvexQuery(queryKey);
+		if (isConvexAction$1(queryKey)) return hashConvexAction(queryKey);
+		return fallback(queryKey);
+	};
+}
+
+//#endregion
+//#region src/solid/client.ts
+/**
+* ConvexQueryClient - Real-time subscription bridge for TanStack Query + Convex (SolidJS)
+*
+* ## Why This Exists
+*
+* TanStack Query is request-based (fetch once, cache, refetch on stale).
+* Convex is subscription-based (WebSocket push updates in real-time).
+*
+* This client bridges the two by:
+* 1. Listening to TanStack Query cache events (query added/removed)
+* 2. Creating Convex WebSocket subscriptions for each active query
+* 3. Pushing Convex updates into TanStack Query cache
+*
+* ## Architecture
+*
+* ```
+* useConvexQuery (hook)
+*       |
+*       v
+* TanStack Query Cache <---- ConvexQueryClient listens to cache events
+*       |                           |
+*       |                           v
+*       |                    Convex WebSocket subscriptions
+*       |                           |
+*       |                           v
+*       +---------------------- Real-time updates pushed to cache
+* ```
+*
+* ## Subscription Lifecycle
+*
+* WebSocket subscriptions are decoupled from cache retention:
+* - Subscribe when query has observers (component mounted)
+* - Unsubscribe immediately when last observer removed (component unmounted)
+* - Cache data persists for gcTime (default 5 min) for instant back-navigation
+* - On remount: show cached data instantly, re-subscribe for fresh updates
+*
+* ## SSR Support
+*
+* On server: Uses ConvexHttpClient for one-shot queries (no WebSocket).
+* On client: Uses ConvexClient with WebSocket subscriptions.
+*
+* @module
+*/
+const isServer = typeof window === "undefined";
+/**
+* Check if query is marked as skipped (used when auth required but not authenticated).
+* Skipped queries have 'skip' as the third element instead of args.
+*/
+function isConvexSkipped(queryKey) {
+	return queryKey.length >= 2 && ["convexQuery", "convexAction"].includes(queryKey[0]) && queryKey[2] === "skip";
+}
+/**
+* Check if query key is for a Convex action function.
+* Format: ['convexAction', 'namespace:functionName', { args }]
+*/
+function isConvexAction(queryKey) {
+	return queryKey.length >= 2 && queryKey[0] === "convexAction";
+}
+/**
+* Bridges TanStack Query with Convex real-time subscriptions (SolidJS).
+*
+* Uses `ConvexClient.onUpdate()` instead of `ConvexReactClient.watchQuery()`.
+*/
+var ConvexQueryClient = class {
+	/** Convex client for WebSocket subscriptions (client) and one-shot queries */
+	convexClient;
+	/**
+	* Active WebSocket subscriptions, keyed by TanStack query hash.
+	* Each subscription has:
+	* - getCurrentValue: getter for latest query result
+	* - unsubscribe: cleanup function to remove the subscription
+	* - queryKey: original query key for cache updates
+	* - lastError: most recent error from onError callback
+	*/
+	subscriptions;
+	/** Cleanup function for QueryCache subscription */
+	unsubscribe;
+	/**
+	* Pending unsubscribes with timeout IDs.
+	* Used to debounce unsubscribe/subscribe cycles.
+	*/
+	pendingUnsubscribes = /* @__PURE__ */ new Map();
+	/** HTTP client for SSR queries (no WebSocket on server) */
+	serverHttpClient;
+	/** TanStack QueryClient reference */
+	_queryClient;
+	/** SSR query mode: 'consistent' guarantees same timestamp, 'inconsistent' is faster */
+	ssrQueryMode;
+	/** Auth store for checking auth state */
+	authStore;
+	/** Delay before unsubscribing when query has no observers */
+	unsubscribeDelay;
+	/** Payload transformer used across request/response boundaries. */
+	transformer;
+	/** Stored URL for creating HTTP client on server */
+	convexUrl;
+	/** Runtime-safe accessor for pending unsubscribe map (defensive for HMR edge cases) */
+	getPendingUnsubscribesMap() {
+		const self = this;
+		if (!self.pendingUnsubscribes) self.pendingUnsubscribes = /* @__PURE__ */ new Map();
+		return self.pendingUnsubscribes;
+	}
+	/** Cancel a pending delayed unsubscribe for a query hash. */
+	cancelPendingUnsubscribe(queryHash) {
+		const pendingUnsubscribes = this.getPendingUnsubscribesMap();
+		const timeoutId = pendingUnsubscribes.get(queryHash);
+		if (!timeoutId) return;
+		clearTimeout(timeoutId);
+		pendingUnsubscribes.delete(queryHash);
+	}
+	/** Unsubscribe a live Convex subscription (if present) and remove it from the subscription map. */
+	unsubscribeQueryByHash(queryHash) {
+		const sub = this.subscriptions[queryHash];
+		if (!sub) return;
+		sub.unsubscribe();
+		delete this.subscriptions[queryHash];
+	}
+	/** Update auth store (for HMR where store may reset) */
+	updateAuthStore(authStore) {
+		this.authStore = authStore;
+	}
+	/** Get current auth state from store */
+	getAuthState() {
+		if (!this.authStore) return;
+		return {
+			isLoading: this.authStore.get("isLoading"),
+			isAuthenticated: this.authStore.get("isAuthenticated"),
+			onUnauthorized: this.authStore.get("onQueryUnauthorized"),
+			isUnauthorized: this.authStore.get("isUnauthorized")
+		};
+	}
+	/**
+	* Check if subscription should be skipped due to auth state.
+	* Needed for useSuspenseQuery which ignores enabled: false.
+	*/
+	shouldSkipSubscription(authType) {
+		if (!authType || !this.authStore) return false;
+		const authState = this.getAuthState();
+		if (authState?.isLoading) return true;
+		if (authType === "required" && !authState?.isAuthenticated) return true;
+		return false;
+	}
+	/** Get QueryClient, throwing if not connected */
+	get queryClient() {
+		if (!this._queryClient) throw new Error("ConvexQueryClient not connected to TanStack QueryClient.");
+		return this._queryClient;
+	}
+	/**
+	* Create a ConvexQueryClient.
+	*
+	* @param client - Convex URL string or existing ConvexClient
+	* @param options - Configuration options
+	*/
+	constructor(client, options = {}) {
+		if (typeof client === "string") {
+			this.convexClient = new ConvexClient(client);
+			this.convexUrl = client;
+		} else {
+			this.convexClient = client;
+			this.convexUrl = client.client.url;
+		}
+		this.ssrQueryMode = options.dangerouslyUseInconsistentQueriesDuringSSR ? "inconsistent" : "consistent";
+		this.subscriptions = {};
+		this.authStore = options.authStore;
+		this.unsubscribeDelay = options.unsubscribeDelay ?? 3e3;
+		this.transformer = getTransformer(options.transformer);
+		if (options.queryClient) {
+			this._queryClient = options.queryClient;
+			this.unsubscribe = this.subscribeInner(options.queryClient.getQueryCache());
+		}
+		if (isServer) this.serverHttpClient = new ConvexHttpClient(this.convexUrl, { fetch: options.serverFetch });
+	}
+	/**
+	* Connect to TanStack QueryClient.
+	* Starts listening to cache events for subscription management.
+	*/
+	connect(queryClient) {
+		if (this._queryClient === queryClient && this.unsubscribe) return;
+		if (this.unsubscribe) this.unsubscribe();
+		this._queryClient = queryClient;
+		this.unsubscribe = this.subscribeInner(queryClient.getQueryCache());
+	}
+	/**
+	* Clean up all subscriptions.
+	* Call this when the client is no longer needed.
+	*/
+	destroy() {
+		this.unsubscribe?.();
+		for (const timeoutId of this.getPendingUnsubscribesMap().values()) clearTimeout(timeoutId);
+		this.getPendingUnsubscribesMap().clear();
+		for (const sub of Object.values(this.subscriptions)) sub.unsubscribe();
+		this.subscriptions = {};
+	}
+	/**
+	* Unsubscribe from all auth-required queries.
+	* Call before logout to prevent UNAUTHORIZED errors during session invalidation.
+	*/
+	unsubscribeAuthQueries() {
+		for (const queryHash of Object.keys(this.subscriptions)) if ((this.queryClient.getQueryCache().get(queryHash)?.meta)?.authType === "required") {
+			this.cancelPendingUnsubscribe(queryHash);
+			this.unsubscribeQueryByHash(queryHash);
+		}
+	}
+	/**
+	* Batch update all subscriptions.
+	* Called internally when Convex client reconnects.
+	*/
+	onUpdate = () => {
+		notifyManager.batch(() => {
+			for (const key of Object.keys(this.subscriptions)) this.onUpdateQueryKeyHash(key);
+		});
+	};
+	/**
+	* Handle Convex subscription update for a specific query.
+	* Reads latest value from getCurrentValue and updates TanStack cache.
+	*
+	* @param queryHash - TanStack query hash identifying the query
+	*/
+	onUpdateQueryKeyHash(queryHash) {
+		const subscription = this.subscriptions[queryHash];
+		if (!subscription) throw new Error(`Internal ConvexQueryClient error: onUpdateQueryKeyHash called for ${queryHash}`);
+		const query = this.queryClient.getQueryCache().get(queryHash);
+		if (!query) return;
+		const { queryKey, getCurrentValue, lastError } = subscription;
+		let result;
+		if (lastError !== void 0) result = {
+			ok: false,
+			error: lastError
+		};
+		else result = {
+			ok: true,
+			value: getCurrentValue()
+		};
+		if (result.ok) {
+			const existingData = this.queryClient.getQueryData(queryKey);
+			if (result.value !== null && result.value !== void 0 || !(existingData !== null && existingData !== void 0)) this.queryClient.setQueryData(queryKey, this.transformer.output.deserialize(result.value));
+		} else {
+			const { error } = result;
+			const authState = this.getAuthState();
+			const meta = query.meta;
+			const isUnauthorized = authState?.isUnauthorized(error) ?? false;
+			if (isUnauthorized && meta?.skipUnauth) {
+				this.queryClient.setQueryData(queryKey, this.transformer.output.deserialize(null));
+				return;
+			}
+			query.setState({
+				error,
+				errorUpdateCount: query.state.errorUpdateCount + 1,
+				errorUpdatedAt: Date.now(),
+				fetchFailureCount: query.state.fetchFailureCount + 1,
+				fetchFailureReason: error,
+				fetchStatus: "idle",
+				status: "error"
+			}, { meta: "set by ConvexQueryClient" });
+			if (isUnauthorized && authState?.isAuthenticated) {
+				const [, funcName] = queryKey;
+				authState.onUnauthorized({ queryName: funcName });
+			}
+		}
+	}
+	/**
+	* Subscribe to TanStack QueryCache events.
+	* Creates/removes Convex WebSocket subscriptions as queries are added/removed.
+	*
+	* @param queryCache - TanStack QueryCache to subscribe to
+	* @returns Cleanup function to unsubscribe
+	*/
+	subscribeInner(queryCache) {
+		if (isServer) return () => {};
+		return queryCache.subscribe((event) => {
+			if (!isConvexQuery(event.query.queryKey)) return;
+			if (isConvexSkipped(event.query.queryKey)) return;
+			switch (event.type) {
+				case "removed":
+					this.cancelPendingUnsubscribe(event.query.queryHash);
+					this.unsubscribeQueryByHash(event.query.queryHash);
+					break;
+				case "added": {
+					const meta = event.query.meta;
+					if (meta?.subscribe === false) break;
+					const [, funcName, args] = event.query.queryKey;
+					if (event.query.getObserversCount() === 0) break;
+					if (this.shouldSkipSubscription(meta?.authType)) break;
+					this.createSubscription(event.query.queryHash, funcName, args, event.query.queryKey);
+					break;
+				}
+				case "observerAdded": {
+					this.cancelPendingUnsubscribe(event.query.queryHash);
+					if (this.subscriptions[event.query.queryHash]) break;
+					if (event.query.options.enabled === false) break;
+					const meta = event.query.meta;
+					if (meta?.subscribe === false) break;
+					const [, funcName, args] = event.query.queryKey;
+					if (this.shouldSkipSubscription(meta?.authType)) break;
+					this.createSubscription(event.query.queryHash, funcName, args, event.query.queryKey);
+					break;
+				}
+				case "observerRemoved":
+					if (event.query.getObserversCount() === 0 && this.subscriptions[event.query.queryHash]) {
+						const queryHash = event.query.queryHash;
+						const timeoutId = setTimeout(() => {
+							this.getPendingUnsubscribesMap().delete(queryHash);
+							if (event.query.getObserversCount() === 0) this.unsubscribeQueryByHash(queryHash);
+						}, this.unsubscribeDelay);
+						this.getPendingUnsubscribesMap().set(queryHash, timeoutId);
+					}
+					break;
+				case "observerResultsUpdated": break;
+				case "updated":
+					if (event.action.type === "setState" && event.action.setStateOptions?.meta === "set by ConvexQueryClient") break;
+					break;
+				case "observerOptionsUpdated": {
+					const isDisabled = event.query.options.enabled === false;
+					const isSubscribed = !!this.subscriptions[event.query.queryHash];
+					if (isDisabled && isSubscribed) {
+						this.cancelPendingUnsubscribe(event.query.queryHash);
+						this.unsubscribeQueryByHash(event.query.queryHash);
+						break;
+					}
+					if (isSubscribed || isDisabled) break;
+					const meta = event.query.meta;
+					if (meta?.subscribe === false) break;
+					const [, funcName, args] = event.query.queryKey;
+					if (this.shouldSkipSubscription(meta?.authType)) break;
+					this.createSubscription(event.query.queryHash, funcName, args, event.query.queryKey);
+					break;
+				}
+			}
+		});
+	}
+	/**
+	* Create a WebSocket subscription via ConvexClient.onUpdate().
+	* Stores the subscription in the subscriptions map.
+	*/
+	createSubscription(queryHash, funcName, args, queryKey) {
+		this.subscriptions[queryHash] = {
+			getCurrentValue: () => void 0,
+			unsubscribe: () => {},
+			queryKey,
+			lastError: void 0
+		};
+		const unsub = this.convexClient.onUpdate(funcName, this.transformer.input.serialize(args), () => {
+			if (this.subscriptions[queryHash]) this.subscriptions[queryHash].lastError = void 0;
+			this.onUpdateQueryKeyHash(queryHash);
+		}, (error) => {
+			if (this.subscriptions[queryHash]) this.subscriptions[queryHash].lastError = error;
+			this.onUpdateQueryKeyHash(queryHash);
+		});
+		this.subscriptions[queryHash].getCurrentValue = unsub.getCurrentValue.bind(unsub);
+		this.subscriptions[queryHash].unsubscribe = () => unsub();
+	}
+	/**
+	* Create default queryFn for TanStack QueryClient.
+	*
+	* Handles:
+	* - Convex queries and actions
+	* - Auth checking (throws CRPCClientError if unauthorized)
+	* - SSR via HTTP client
+	* - Client via WebSocket client
+	*
+	* @param otherFetch - Fallback queryFn for non-Convex queries
+	* @returns QueryFunction compatible with TanStack Query
+	*/
+	queryFn(otherFetch = throwBecauseNotConvexQuery) {
+		return async (context) => {
+			const { queryKey, meta: rawMeta } = context;
+			const meta = rawMeta;
+			if (isConvexSkipped(queryKey)) throw new Error("Skipped query should not actually run, should { enabled: false }");
+			if (isConvexQuery(queryKey)) {
+				const [, funcName, args] = queryKey;
+				const wireArgs = this.transformer.input.serialize(args);
+				const skipUnauth = meta?.skipUnauth ?? false;
+				if (meta?.authType === "required" && !isServer && this.authStore) {
+					const authState = this.getAuthState();
+					if (authState && !authState.isLoading && !authState.isAuthenticated) {
+						if (skipUnauth) return null;
+						authState.onUnauthorized({ queryName: funcName });
+						throw new CRPCClientError({
+							code: "UNAUTHORIZED",
+							functionName: funcName
+						});
+					}
+				}
+				try {
+					if (isServer) {
+						if (this.ssrQueryMode === "consistent") return this.transformer.output.deserialize(await this.serverHttpClient.consistentQuery(funcName, wireArgs));
+						return this.transformer.output.deserialize(await this.serverHttpClient.query(funcName, wireArgs));
+					}
+					return this.transformer.output.deserialize(await this.convexClient.query(funcName, wireArgs));
+				} catch (error) {
+					if (skipUnauth && defaultIsUnauthorized(error)) return null;
+					throw error;
+				}
+			}
+			if (isConvexAction(queryKey)) {
+				const [, funcName, args] = queryKey;
+				const wireArgs = this.transformer.input.serialize(args);
+				const skipUnauth = meta?.skipUnauth ?? false;
+				if (meta?.authType === "required" && !isServer && this.authStore) {
+					const authState = this.getAuthState();
+					if (authState && !authState.isLoading && !authState.isAuthenticated) {
+						if (skipUnauth) return null;
+						authState.onUnauthorized({ queryName: funcName });
+						throw new CRPCClientError({
+							code: "UNAUTHORIZED",
+							functionName: funcName
+						});
+					}
+				}
+				try {
+					if (isServer) return this.transformer.output.deserialize(await this.serverHttpClient.action(funcName, wireArgs));
+					return this.transformer.output.deserialize(await this.convexClient.action(funcName, wireArgs));
+				} catch (error) {
+					if (skipUnauth && defaultIsUnauthorized(error)) return null;
+					throw error;
+				}
+			}
+			return otherFetch(context);
+		};
+	}
+	/**
+	* Create hash function for TanStack QueryClient.
+	*
+	* Uses Convex-specific hashing for Convex queries to ensure
+	* consistent cache keys across serialization.
+	*
+	* @param fallback - Fallback hash function for non-Convex queries
+	* @returns Hash function compatible with TanStack Query
+	*/
+	hashFn(fallback) {
+		return createHashFn(fallback);
+	}
+};
+/** Default fallback queryFn that throws for non-Convex queries */
+function throwBecauseNotConvexQuery(context) {
+	throw new Error(`Query key is not for a Convex Query: ${context.queryKey}`);
+}
+
+//#endregion
+//#region src/solid/convex-auth-provider.tsx
+/** @jsxImportSource solid-js */
+/**
+* Unified Convex + Better Auth provider for SolidJS
+*
+* Port of the React ConvexAuthProvider to SolidJS.
+* Handles token sync and auth callbacks.
+*/
+const defaultMutationHandler = () => {
+	throw new CRPCClientError({
+		code: "UNAUTHORIZED",
+		functionName: "mutation"
+	});
+};
+const hasActiveSessionData = (session) => {
+	if (!session || typeof session !== "object") return false;
+	return Boolean(session.session);
+};
+/**
+* Unified auth provider for Convex + Better Auth (SolidJS).
+* Handles token sync and auth callbacks.
+*
+* Structure: AuthProvider wraps ConvexAuthProviderInner so that
+* useAuthStore() is available when creating fetchAccessToken.
+*/
+function ConvexAuthProvider(props) {
+	useOTTHandler(props.authClient);
+	const tokenValues = () => ({
+		expiresAt: props.initialToken ? decodeJwtExp(props.initialToken) : null,
+		token: props.initialToken ?? null
+	});
+	return createComponent(AuthProvider, {
+		get initialValues() {
+			return tokenValues();
+		},
+		get isUnauthorized() {
+			return props.isUnauthorized ?? defaultIsUnauthorized;
+		},
+		get onMutationUnauthorized() {
+			return props.onMutationUnauthorized ?? defaultMutationHandler;
+		},
+		get onQueryUnauthorized() {
+			return props.onQueryUnauthorized ?? (() => {});
+		},
+		get children() {
+			return createComponent(ConvexAuthProviderInner, {
+				get authClient() {
+					return props.authClient;
+				},
+				get client() {
+					return props.client;
+				},
+				get children() {
+					return props.children;
+				}
+			});
+		}
+	});
+}
+/**
+* Inner provider that has access to AuthStore via useAuthStore().
+* Creates fetchAccessToken and passes it through context.
+*/
+function ConvexAuthProviderInner(props) {
+	const authStore = useAuthStore();
+	const sessionAccessor = props.authClient.useSession();
+	let pendingTokenPromise = null;
+	createEffect(() => {
+		const sessionState = sessionAccessor();
+		const session = sessionState.data;
+		const isPending = sessionState.isPending;
+		if (!hasActiveSessionData(session) && !isPending) {
+			authStore.set("token", null);
+			authStore.set("expiresAt", null);
+			authStore.set("isAuthenticated", false);
+		}
+	});
+	const fetchAccessToken = async ({ forceRefreshToken = false } = {}) => {
+		const sessionState = sessionAccessor();
+		const currentSession = sessionState.data;
+		const currentIsPending = sessionState.isPending;
+		if (!hasActiveSessionData(currentSession)) {
+			if (!currentIsPending) {
+				authStore.set("token", null);
+				authStore.set("expiresAt", null);
+			}
+			return authStore.get("token");
+		}
+		const cachedToken = authStore.get("token");
+		const expiresAt = authStore.get("expiresAt");
+		const timeRemaining = expiresAt ? expiresAt - Date.now() : 0;
+		if (!forceRefreshToken && cachedToken && expiresAt && timeRemaining >= 6e4) return cachedToken;
+		if (!forceRefreshToken && pendingTokenPromise) return pendingTokenPromise;
+		const fetchOptions = { throw: false };
+		if (cachedToken && decodeJwtExp(cachedToken) === null) fetchOptions.headers = { Authorization: `Bearer ${cachedToken}` };
+		pendingTokenPromise = props.authClient.convex.token({ fetchOptions }).then((result) => {
+			const jwt = result.data?.token || null;
+			if (jwt) {
+				const exp = decodeJwtExp(jwt);
+				authStore.set("token", jwt);
+				authStore.set("expiresAt", exp);
+				return jwt;
+			}
+			authStore.set("token", null);
+			authStore.set("expiresAt", null);
+			return null;
+		}).catch((error) => {
+			authStore.set("token", null);
+			authStore.set("expiresAt", null);
+			console.error("[fetchAccessToken] error", error);
+			return null;
+		}).finally(() => {
+			pendingTokenPromise = null;
+		});
+		return pendingTokenPromise;
+	};
+	const useAuth = () => {
+		const sessionState = sessionAccessor();
+		const hasSession = hasActiveSessionData(sessionState.data);
+		const sessionMissing = !hasSession && !sessionState.isPending;
+		const token = authStore.get("token");
+		return {
+			isLoading: sessionState.isPending && !token,
+			isAuthenticated: sessionMissing ? false : hasSession || token !== null,
+			fetchAccessToken
+		};
+	};
+	return createComponent(FetchAccessTokenContext.Provider, {
+		value: fetchAccessToken,
+		get children() {
+			return createComponent(ConvexProviderWithAuth, {
+				get client() {
+					return props.client;
+				},
+				useAuth,
+				get children() {
+					return createComponent(AuthStateSync, { get children() {
+						return props.children;
+					} });
+				}
+			});
+		}
+	});
+}
+/**
+* Syncs auth state from useConvexAuth() to the auth store.
+* MUST be inside ConvexProviderWithAuth to access useConvexAuth().
+*
+* Defensive isLoading computation handles SSR hydration race:
+* 1. SSR sets token from cookie
+* 2. Client hydrates
+* 3. Better Auth's useSession() briefly returns null before loading cookie
+* 4. Convex sets isConvexAuthenticated = false (no auth to wait for)
+* 5. Without defensive check, we'd sync { isLoading: false, isAuthenticated: false }
+* 6. Queries would throw UNAUTHORIZED before token is validated
+*/
+function AuthStateSync(props) {
+	const convexAuth = useConvexAuth();
+	const authStore = useAuthStore();
+	createEffect(() => {
+		const hasTokenButNotAuth = !!authStore.get("token") && !convexAuth.isAuthenticated;
+		const isLoading = convexAuth.isLoading || hasTokenButNotAuth;
+		authStore.set("isLoading", isLoading);
+		authStore.set("isAuthenticated", convexAuth.isAuthenticated);
+	});
+	return props.children;
+}
+/**
+* Handles cross-domain one-time token (OTT) verification.
+*/
+function useOTTHandler(authClient) {
+	onMount(async () => {
+		if (typeof window === "undefined" || !window.location?.href) return;
+		const url = new URL(window.location.href);
+		const token = url.searchParams.get("ott");
+		if (token) {
+			const authClientWithCrossDomain = authClient;
+			url.searchParams.delete("ott");
+			window.history.replaceState({}, "", url);
+			const session = (await authClientWithCrossDomain.crossDomain.oneTimeToken.verify({ token })).data?.session;
+			if (session) {
+				await authClient.getSession({ fetchOptions: { headers: { Authorization: `Bearer ${session.token}` } } });
+				authClientWithCrossDomain.updateSession();
+			}
+		}
+	});
+}
+
+//#endregion
+//#region src/solid/singleton.ts
+const globalStore = globalThis;
+/** Get/create QueryClient singleton (fresh on SSR, singleton on client) */
+const getQueryClientSingleton = (factory, symbolKey = "convex.queryClient") => {
+	const key = Symbol.for(symbolKey);
+	if (typeof window === "undefined") return factory();
+	if (!globalStore[key]) globalStore[key] = factory();
+	return globalStore[key];
+};
+/** Get/create ConvexQueryClient singleton (fresh on SSR, singleton on client) */
+const getConvexQueryClientSingleton = ({ authStore, convex, queryClient, symbolKey = "convex.convexQueryClient", unsubscribeDelay, transformer }) => {
+	const key = Symbol.for(symbolKey);
+	const isServer = typeof window === "undefined";
+	let client;
+	if (isServer) client = new ConvexQueryClient(convex, {
+		authStore,
+		unsubscribeDelay,
+		transformer
+	});
+	else {
+		if (globalStore[key]) globalStore[key].updateAuthStore(authStore);
+		else globalStore[key] = new ConvexQueryClient(convex, {
+			authStore,
+			unsubscribeDelay,
+			transformer
+		});
+		client = globalStore[key];
+		client.connect(queryClient);
+	}
+	const currentOpts = queryClient.getDefaultOptions();
+	queryClient.setDefaultOptions({
+		...currentOpts,
+		queries: {
+			...currentOpts.queries,
+			queryFn: client.queryFn(),
+			queryKeyHashFn: client.hashFn()
+		}
+	});
+	return client;
+};
+
+//#endregion
+//#region src/solid/use-infinite-query.ts
+const PAGINATION_KEY_PREFIX = "__pagination__";
+const paginationIdStore = /* @__PURE__ */ new Map();
+let paginationIdCounter = 0;
+const getOrCreatePaginationId = (storeKey) => {
+	const existing = paginationIdStore.get(storeKey);
+	if (existing !== void 0) return existing;
+	const newId = ++paginationIdCounter;
+	paginationIdStore.set(storeKey, newId);
+	return newId;
+};
+/** Build a unique key for recovery attempt detection */
+const buildRecoveryKey = (pageKeys, page0Cursor, page0UpdatedAt) => JSON.stringify({
+	pageKeys,
+	page0Cursor,
+	page0UpdatedAt
+});
+/**
+* Hook for auto-recovering from stale cursors after WebSocket reconnection.
+*
+* When Convex WebSocket reconnects, page 0 (cursor: null) resubscribes and
+* gets fresh data. However, pages 1+ may have stale cursors that fail.
+*
+* This hook detects this pattern and creates a recovery page that fetches
+* enough items to cover the lost pages, preserving the user's scroll position.
+*/
+const useStaleCursorRecovery = ({ argsObject, combined, limit, setState, state }) => {
+	createEffect(on([
+		() => combined.isFetchNextPageError,
+		() => combined._rawResults,
+		() => state().pageKeys,
+		() => state().queries,
+		() => state().autoRecoveryAttempted,
+		argsObject
+	], () => {
+		if (!combined.isFetchNextPageError) return;
+		const page0Result = combined._rawResults[0];
+		const page0Data = page0Result?.data;
+		const page0UpdatedAt = page0Result?.dataUpdatedAt ?? 0;
+		const hasPage0Data = page0Data !== void 0 && !page0Result?.isError;
+		const hasSubsequentErrors = combined._rawResults.slice(1).some((q) => q?.isError && !q?.isFetching);
+		if (!hasPage0Data || !hasSubsequentErrors || !page0Data?.continueCursor) return;
+		const currentState = state();
+		const recoveryKey = buildRecoveryKey(currentState.pageKeys, page0Data.continueCursor, page0UpdatedAt);
+		if (currentState.autoRecoveryAttempted === recoveryKey) return;
+		const erroredPageKeys = currentState.pageKeys.filter((_, i) => i > 0 && combined._rawResults[i]?.isError);
+		const itemsToRecover = erroredPageKeys.reduce((sum, key) => {
+			return sum + (currentState.queries[key]?.args?.limit ?? limit ?? 20);
+		}, 0);
+		console.warn("[Pagination] Auto-recovering from stale cursors", {
+			erroredPages: erroredPageKeys.length,
+			itemsToRecover
+		});
+		setState((prev) => ({
+			...prev,
+			id: prev.id,
+			nextPageKey: 2,
+			pageKeys: [prev.pageKeys[0], 1],
+			queries: {
+				[prev.pageKeys[0]]: prev.queries[prev.pageKeys[0]],
+				1: { args: {
+					...argsObject(),
+					cursor: page0Data.continueCursor,
+					limit: Math.min(itemsToRecover + (limit ?? 20), 500),
+					__paginationId: prev.id
+				} }
+			},
+			version: prev.version + 1,
+			autoRecoveryAttempted: recoveryKey
+		}));
+	}));
+	createEffect(on([() => combined.status, () => state().autoRecoveryAttempted], () => {
+		if ((combined.status === "CanLoadMore" || combined.status === "Exhausted") && state().autoRecoveryAttempted) setState((prev) => ({
+			...prev,
+			autoRecoveryAttempted: void 0
+		}));
+	}));
+};
+/**
+* Internal infinite query hook using TanStack Query + convexQuery.
+* Each page gets:
+* - Convex WebSocket subscription (real-time reactivity)
+* - TanStack Query retry on timeout errors
+*
+* Use `useInfiniteQuery` for the public API with auth handling.
+*/
+const useInfiniteQueryInternal = (query, args, options) => {
+	const { limit, enabled, placeholderData, ...queryOptions } = options;
+	const safeAuth = useSafeConvexAuth();
+	const meta = useMeta();
+	const queryClient = useQueryClient();
+	const prefetchedFirstPage = createMemo(() => {
+		const serverQueryKey = [
+			"convexQuery",
+			getFunctionName(query),
+			{
+				...args,
+				cursor: null,
+				limit
+			}
+		];
+		return queryClient.getQueryData(serverQueryKey) ?? null;
+	});
+	const skip = createMemo(() => !prefetchedFirstPage() && (safeAuth.isLoading || enabled === false));
+	const getPaginationState = (key) => {
+		const queryKey = [PAGINATION_KEY_PREFIX, key];
+		return queryClient.getQueryData(queryKey);
+	};
+	const setPaginationState = (key, paginationState) => {
+		const queryKey = [PAGINATION_KEY_PREFIX, key];
+		queryClient.setQueryData(queryKey, paginationState);
+	};
+	const argsObject = createMemo(() => skip() ? {} : args);
+	const storeKey = createMemo(() => JSON.stringify({
+		query: getFunctionName(query),
+		args: argsObject()
+	}));
+	const createInitialState = () => {
+		const id = getOrCreatePaginationId(storeKey());
+		return {
+			id,
+			nextPageKey: 1,
+			pageKeys: skip() ? [] : [0],
+			queries: skip() ? {} : { 0: { args: {
+				...argsObject(),
+				cursor: null,
+				limit,
+				__paginationId: id
+			} } },
+			version: 0
+		};
+	};
+	let prevArgs = null;
+	const computeInitialState = () => {
+		if (skip()) return {
+			id: 0,
+			nextPageKey: 1,
+			pageKeys: [],
+			queries: {},
+			version: 0
+		};
+		const existingState = getPaginationState(storeKey());
+		if (existingState) return existingState;
+		return createInitialState();
+	};
+	const [state, setLocalState] = createSignal(computeInitialState());
+	const setState = (updater) => {
+		setLocalState((prev) => {
+			const newState = typeof updater === "function" ? updater(prev) : updater;
+			setPaginationState(storeKey(), newState);
+			return newState;
+		});
+	};
+	createEffect(on([skip, storeKey], () => {
+		const prev = prevArgs;
+		const isFirstRun = prev === null;
+		const currentStoreKey = storeKey();
+		const currentSkip = skip();
+		const argsChanged = prev !== null && (prev.storeKey !== currentStoreKey || prev.skip !== currentSkip);
+		const skipBecameFalse = prev?.skip && !currentSkip;
+		prevArgs = {
+			storeKey: currentStoreKey,
+			skip: currentSkip
+		};
+		if (currentSkip) return;
+		if (isFirstRun) {
+			setPaginationState(currentStoreKey, state());
+			return;
+		}
+		if (skipBecameFalse) {
+			const existingState = getPaginationState(currentStoreKey);
+			if (existingState) {
+				setLocalState(existingState);
+				return;
+			}
+			const newState = createInitialState();
+			setLocalState(newState);
+			setPaginationState(currentStoreKey, newState);
+			return;
+		}
+		if (argsChanged) {
+			const existingState = getPaginationState(currentStoreKey);
+			if (existingState) {
+				setLocalState(existingState);
+				return;
+			}
+			const newState = createInitialState();
+			setLocalState(newState);
+			setPaginationState(currentStoreKey, newState);
+		}
+	}));
+	const tanstackQueries = createMemo(() => state().pageKeys.map((key, index) => {
+		const pageArgs = state().queries[key]?.args;
+		return {
+			...convexQuery(query, pageArgs ? (({ __paginationId, ...rest }) => rest)(pageArgs) : "skip", meta),
+			enabled: !skip() && !!state().queries[key],
+			structuralSharing: false,
+			...queryOptions ?? {},
+			...index === 0 && prefetchedFirstPage() ? { initialData: prefetchedFirstPage() } : {},
+			...index === 0 && placeholderData ? { placeholderData: {
+				page: placeholderData,
+				isDone: false,
+				continueCursor: null
+			} } : {}
+		};
+	}));
+	const combined = useQueries(() => ({
+		queries: tanstackQueries(),
+		combine: (results) => {
+			const allItems = [];
+			const pages = [];
+			const seenIds = /* @__PURE__ */ new Set();
+			let lastPage;
+			let paginationStatus = "LoadingFirstPage";
+			for (let i = 0; i < results.length; i++) {
+				const pageQuery = results[i];
+				if (pageQuery.isLoading || pageQuery.data === void 0) {
+					paginationStatus = i === 0 ? "LoadingFirstPage" : "LoadingMore";
+					break;
+				}
+				const page = pageQuery.data;
+				lastPage = page;
+				pages.push(page.page);
+				for (const item of page.page) {
+					const id = item._id || item.id;
+					if (id && seenIds.has(id)) continue;
+					if (id) seenIds.add(id);
+					allItems.push(item);
+				}
+				paginationStatus = page.isDone ? "Exhausted" : "CanLoadMore";
+			}
+			const isPlaceholderData = results[0]?.isPlaceholderData ?? !!placeholderData;
+			const isFetching = results.some((r) => r.isFetching);
+			return {
+				data: allItems,
+				dataUpdatedAt: Math.max(...results.map((r) => r.dataUpdatedAt ?? 0)),
+				lastPage,
+				pages,
+				status: paginationStatus,
+				error: results.find((r) => r.isError)?.error ?? null,
+				isError: results.some((r) => r.isError),
+				isFetching,
+				isFetchNextPageError: results.length > 1 && (results.at(-1)?.isError ?? false),
+				isPlaceholderData,
+				isRefetching: isFetching && allItems.length > 0 && !isPlaceholderData,
+				isLoading: paginationStatus === "LoadingFirstPage",
+				failureReason: results.find((r) => r.isError)?.error ?? null,
+				_rawResults: results
+			};
+		}
+	}));
+	useStaleCursorRecovery({
+		argsObject,
+		combined,
+		limit,
+		setState,
+		state
+	});
+	createEffect(on([
+		() => combined._rawResults,
+		() => state().pageKeys,
+		() => state().queries,
+		argsObject
+	], () => {
+		for (let i = 0; i < combined._rawResults.length; i++) {
+			const pageQuery = combined._rawResults[i];
+			if (pageQuery.data) {
+				const page = pageQuery.data;
+				const pageKey = state().pageKeys[i];
+				const pageState = state().queries[pageKey];
+				if (page.splitCursor && pageState && !pageState.endCursor) {
+					setState((prev) => {
+						const currentPageState = prev.queries[pageKey];
+						if (!currentPageState || currentPageState.endCursor) return prev;
+						const newKey = prev.nextPageKey;
+						const splitCursor = page.splitCursor;
+						const splitPageArgs = {
+							...argsObject(),
+							cursor: splitCursor,
+							limit: currentPageState.args.limit,
+							__paginationId: prev.id
+						};
+						const pageKeyIndex = prev.pageKeys.indexOf(pageKey);
+						const newPageKeys = [...prev.pageKeys];
+						newPageKeys.splice(pageKeyIndex + 1, 0, newKey);
+						return {
+							...prev,
+							nextPageKey: newKey + 1,
+							pageKeys: newPageKeys,
+							queries: {
+								...prev.queries,
+								[pageKey]: {
+									...currentPageState,
+									endCursor: splitCursor
+								},
+								[newKey]: { args: splitPageArgs }
+							}
+						};
+					});
+					return;
+				}
+			}
+		}
+	}));
+	const loadMore = (pageLimit) => {
+		if (combined.status !== "CanLoadMore" || !combined.lastPage?.continueCursor) return;
+		setState((prev) => {
+			const newKey = prev.nextPageKey;
+			return {
+				...prev,
+				nextPageKey: newKey + 1,
+				pageKeys: [...prev.pageKeys, newKey],
+				queries: {
+					...prev.queries,
+					[newKey]: { args: {
+						...argsObject(),
+						cursor: combined.lastPage.continueCursor,
+						limit: pageLimit,
+						__paginationId: prev.id
+					} }
+				}
+			};
+		});
+	};
+	const hasNextPage = createMemo(() => combined.status === "CanLoadMore");
+	const isFetchingNextPage = createMemo(() => combined.status === "LoadingMore");
+	return {
+		get data() {
+			return combined.data;
+		},
+		get error() {
+			return combined.error instanceof Error ? combined.error : null;
+		},
+		get failureReason() {
+			return combined.failureReason ?? null;
+		},
+		get isFetchNextPageError() {
+			return combined.isFetchNextPageError;
+		},
+		get isError() {
+			return combined.isError;
+		},
+		get isFetching() {
+			return combined.isFetching;
+		},
+		get isFetchingNextPage() {
+			return isFetchingNextPage();
+		},
+		get isLoading() {
+			return combined.isLoading;
+		},
+		get isPlaceholderData() {
+			return combined.isPlaceholderData;
+		},
+		get isRefetching() {
+			return combined.isRefetching;
+		},
+		fetchNextPage: (n) => loadMore(n ?? limit),
+		get hasNextPage() {
+			return hasNextPage();
+		},
+		get pages() {
+			return combined.pages;
+		},
+		get status() {
+			return combined.status;
+		}
+	};
+};
+/**
+* Infinite query hook using cRPC-style options.
+* Accepts options from `crpc.posts.list.infiniteQueryOptions()`.
+*
+* @example
+* ```tsx
+* const crpc = useCRPC();
+* const { data, fetchNextPage } = useInfiniteQuery(
+*   crpc.posts.list.infiniteQueryOptions({ userId }, { limit: 20 })
+* );
+* ```
+*/
+function useInfiniteQuery(infiniteOptions) {
+	const query = infiniteOptions[FUNC_REF_SYMBOL];
+	const onQueryUnauthorized = useAuthValue("onQueryUnauthorized");
+	const safeAuth = useSafeConvexAuth();
+	const { queryKey: _queryKey, staleTime: _staleTime, refetchInterval: _refetchInterval, refetchOnMount: _refetchOnMount, refetchOnReconnect: _refetchOnReconnect, refetchOnWindowFocus: _refetchOnWindowFocus, enabled: factoryEnabled, meta, ...queryOptions } = infiniteOptions;
+	const { queryName, args, limit, authType, skipUnauth } = meta;
+	const skipUnauthFinal = skipUnauth ?? false;
+	const isUnauthorized = authType === "required" && !safeAuth.isLoading && !safeAuth.isAuthenticated;
+	const shouldSkip = factoryEnabled === false || authType === "required" && safeAuth.isLoading || authType === "required" && !safeAuth.isAuthenticated;
+	const authError = createMemo(() => {
+		if (isUnauthorized && !skipUnauthFinal) return new CRPCClientError({
+			code: "UNAUTHORIZED",
+			functionName: queryName
+		});
+		return null;
+	});
+	createEffect(() => {
+		if (isUnauthorized && !skipUnauthFinal) onQueryUnauthorized({ queryName });
+	});
+	const result = useInfiniteQueryInternal(query, args, {
+		limit,
+		...queryOptions,
+		enabled: !shouldSkip
+	});
+	const authLoadingApplies = authType === "optional" || authType === "required";
+	const isSkippedUnauth = isUnauthorized && skipUnauthFinal;
+	return {
+		get data() {
+			return isSkippedUnauth ? [] : result.data;
+		},
+		get pages() {
+			return isSkippedUnauth ? [] : result.pages;
+		},
+		get error() {
+			return authError() ?? result.error;
+		},
+		get isError() {
+			return authError() ? true : result.isError;
+		},
+		get isPlaceholderData() {
+			return isSkippedUnauth ? false : result.isPlaceholderData;
+		},
+		get isLoading() {
+			const ae = authError();
+			const isClientError = isCRPCClientError(result.error);
+			return authLoadingApplies && safeAuth.isLoading || !isClientError && !ae && !isSkippedUnauth && result.isLoading;
+		},
+		get isFetching() {
+			return result.isFetching;
+		},
+		get isFetchingNextPage() {
+			return result.isFetchingNextPage;
+		},
+		get isFetchNextPageError() {
+			return result.isFetchNextPageError;
+		},
+		get isRefetching() {
+			return result.isRefetching;
+		},
+		get failureReason() {
+			return result.failureReason;
+		},
+		fetchNextPage: result.fetchNextPage,
+		get hasNextPage() {
+			return result.hasNextPage;
+		},
+		get status() {
+			return result.status;
+		}
+	};
+}
+
+//#endregion
+export { AuthMutationError, AuthProvider, Authenticated, ConvexAuthBridge, ConvexAuthProvider, ConvexProvider, ConvexProviderWithAuth, ConvexQueryClient, FetchAccessTokenContext, MaybeAuthenticated, MaybeUnauthenticated, MetaContext, Unauthenticated, createAuthMutations, createCRPCContext, createCRPCOptionsProxy, createHttpProxy, createVanillaCRPCProxy, decodeJwtExp, getAuthType, getConvexQueryClientSingleton, getQueryClientSingleton, isAuthMutationError, useAuth, useAuthGuard, useAuthSkip, useAuthStore, useAuthValue, useConvex, useConvexActionOptions, useConvexActionQueryOptions, useConvexAuth, useConvexAuthBridge, useConvexInfiniteQueryOptions, useConvexMutationOptions, useConvexQueryClient, useConvexQueryOptions, useFetchAccessToken, useFnMeta, useInfiniteQuery, useIsAuth, useMaybeAuth, useMeta, useSafeConvexAuth, useUploadMutationOptions };