kitcn 0.17.4 → 0.18.0

package/dist/{query-context-C90vNlc9.js → query-context-CJE_hYA3.js}

@@ -23,6 +23,27 @@ function isFieldReference(value) {
 	return value && typeof value === "object" && value.__brand === "FieldReference";
 }
 /**
+* The pattern is the same for every row of a scan while the value is not, so
+* only the value genuinely has to be split per call. A small bounded cache
+* keeps the split pattern across rows without unbounded growth on
+* caller-supplied patterns; a query with a handful of LIKE filters still hits
+* on every row.
+*/
+const LIKE_PATTERN_CACHE_MAX = 16;
+const likePatternCache = /* @__PURE__ */ new Map();
+function likePatternCodePoints(pattern, caseInsensitive) {
+	const key = caseInsensitive ? `i:${pattern}` : `s:${pattern}`;
+	const cached = likePatternCache.get(key);
+	if (cached) return cached;
+	const source = Array.from(caseInsensitive ? pattern.toLowerCase() : pattern);
+	if (likePatternCache.size >= LIKE_PATTERN_CACHE_MAX) for (const oldest of likePatternCache.keys()) {
+		likePatternCache.delete(oldest);
+		break;
+	}
+	likePatternCache.set(key, source);
+	return source;
+}
+/**
 * SQL `LIKE` semantics: `%` matches any run of characters, `_` matches exactly
 * one, everything else is literal. Wildcards work anywhere in the pattern, not
 * only at the ends.
@@ -36,7 +57,7 @@ function isFieldReference(value) {
 */
 function matchLikePattern(value, pattern, caseInsensitive) {
 	const target = Array.from(caseInsensitive ? value.toLowerCase() : value);
-	const source = Array.from(caseInsensitive ? pattern.toLowerCase() : pattern);
+	const source = likePatternCodePoints(pattern, caseInsensitive);
 	let valueIndex = 0;
 	let patternIndex = 0;
 	let wildcardPatternIndex = -1;

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
 'use client';
-import { A as useSafeConvexAuth, C as useAuthStore, D as useFetchAccessToken, E as useConvexAuthRecovery, O as useIsAuth, S as useAuthState, T as useConvexAuthBridge, _ as Unauthenticated, a as Authenticated, b as useAuth, c as ConvexAuthRecoveryError, d as ConvexAuthRecoveryStatus, f as ConvexProviderWithAuth, g as MaybeUnauthenticated, h as MaybeAuthenticated, i as AuthStoreState, k as useMaybeAuth, l as ConvexAuthRecoveryErrorCode, m as FetchAccessTokenFn, n as AuthProvider, o as ConvexAuthBridge, p as FetchAccessTokenContext, r as AuthStore, s as ConvexAuthRecovery, t as AUTH_SESSION_SYNC_GRACE_MS, u as ConvexAuthRecoveryOptions, v as decodeJwtExp, w as useAuthValue, x as useAuthGuard, y as isSessionSyncGraceActive } from "../auth-store-GDNKweSK.js";
+import { A as decodeJwtExp, C as useAuthValue, D as useIsAuth, E as useFetchAccessToken, O as useMaybeAuth, S as useAuthStore, T as useConvexAuthRecovery, _ as Unauthenticated, a as Authenticated, b as useAuthGuard, c as ConvexAuthRecoveryError, d as ConvexAuthRecoveryStatus, f as ConvexProviderWithAuth, g as MaybeUnauthenticated, h as MaybeAuthenticated, i as AuthStoreState, k as useSafeConvexAuth, l as ConvexAuthRecoveryErrorCode, m as FetchAccessTokenFn, n as AuthProvider, o as ConvexAuthBridge, p as FetchAccessTokenContext, r as AuthStore, s as ConvexAuthRecovery, t as AUTH_SESSION_SYNC_GRACE_MS, u as ConvexAuthRecoveryOptions, v as isSessionSyncGraceActive, w as useConvexAuthBridge, x as useAuthState, y as useAuth } from "../auth-store-47WTg13B.js";
 import { ConvexProvider, ConvexReactClient, ConvexReactClient as ConvexReactClient$1, ConvexReactClientOptions, Watch, WatchQueryOptions, useConvex } from "convex/react";
 import { ReactNode } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";
@@ -236,7 +236,6 @@ declare class ConvexQueryClient {
   /** Unsubscribe a live Convex watch (if present) and remove it from the subscription map. */
   private unsubscribeQueryByHash;
   private isAuthBoundQuery;
-  private isQueryDisabled;
   private subscribeQuery;
   /** Update auth store (for HMR where jotai store may reset) */
   updateAuthStore(authStore?: AuthStore): void;
@@ -986,6 +985,12 @@ declare function useInfiniteQuery<T extends FunctionReference<'query'>, TItem =
 //#region src/react/use-query-options.d.ts
 type ReservedQueryOptions = 'queryKey' | 'queryFn' | 'staleTime';
 type ReservedMutationOptions = 'mutationFn';
+type QueryOptionsResult<T extends FunctionReference<'query'>> = ConvexQueryOptions<T> & {
+  meta: ConvexQueryMeta;
+};
+type ActionQueryOptionsResult<T extends FunctionReference<'action'>> = ConvexActionOptions<T> & {
+  meta: ConvexQueryMeta;
+};
 /**
  * Hook that returns query options for use with useQuery.
  * Handles skipUnauth by setting enabled: false when unauthorized.
@@ -1010,9 +1015,7 @@ type ReservedMutationOptions = 'mutationFn';
  * const { data } = useQuery(useConvexQueryOptions(api.user.get, { id }, { enabled: !!id, placeholderData: [] }));
  * ```
  */
-declare function useConvexQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: FunctionArgs<T> | SkipToken, options?: ConvexQueryHookOptions & DistributiveOmit<UseQueryOptions<FunctionReturnType<T>, DefaultError>, ReservedQueryOptions>): ConvexQueryOptions<T> & {
-  meta: ConvexQueryMeta;
-};
+declare function useConvexQueryOptions<T extends FunctionReference<'query'>>(funcRef: T, args: FunctionArgs<T> | SkipToken, options?: ConvexQueryHookOptions & DistributiveOmit<UseQueryOptions<FunctionReturnType<T>, DefaultError>, ReservedQueryOptions>): QueryOptionsResult<T>;
 /**
  * Hook that returns infinite query options for use with useInfiniteQuery.
  * Handles auth type detection from meta and skipUnauth.
@@ -1060,9 +1063,7 @@ declare function useConvexInfiniteQueryOptions<T extends FunctionReference<'quer
  */
 declare function useConvexActionQueryOptions<Action extends FunctionReference<'action'>>(action: Action, args: FunctionArgs<Action> | SkipToken, options?: {
   skipUnauth?: boolean;
-} & DistributiveOmit<UseQueryOptions<FunctionReturnType<Action>, DefaultError>, ReservedQueryOptions>): ConvexActionOptions<Action> & {
-  meta: ConvexQueryMeta;
-};
+} & DistributiveOmit<UseQueryOptions<FunctionReturnType<Action>, DefaultError>, ReservedQueryOptions>): ActionQueryOptionsResult<Action>;
 /**
  * Hook that returns mutation options for use with useMutation.
  * Wraps the Convex mutation with auth guard logic.

package/dist/react/index.js

@@ -1,5 +1,5 @@
 'use client';
-import { A as defaultIsUnauthorized, C as useSafeConvexAuth, D as writeAuthSessionFallbackData, O as writeAuthSessionFallbackToken, S as useMaybeAuth, _ as useAuthValue, a as ConvexAuthRecoveryError, b as useFetchAccessToken, c as MaybeAuthenticated, d as decodeJwtExp, f as isSessionSyncGraceActive, g as useAuthStore, h as useAuthState, i as ConvexAuthBridge, j as isCRPCClientError, k as CRPCClientError, l as MaybeUnauthenticated, m as useAuthGuard, n as AuthProvider, o as ConvexProviderWithAuth, p as useAuth, r as Authenticated, s as FetchAccessTokenContext, t as AUTH_SESSION_SYNC_GRACE_MS, u as Unauthenticated, v as useConvexAuthBridge, w as clearAuthSessionFallback, x as useIsAuth, y as useConvexAuthRecovery } from "../auth-store-BnGZxmnY.js";
+import { A as CRPCClientError, C as decodeJwtExp, M as isCRPCClientError, O as writeAuthSessionFallbackData, S as useSafeConvexAuth, T as clearAuthSessionFallback, _ as useConvexAuthBridge, a as ConvexAuthRecoveryError, b as useIsAuth, c as MaybeAuthenticated, d as isSessionSyncGraceActive, f as useAuth, g as useAuthValue, h as useAuthStore, i as ConvexAuthBridge, j as defaultIsUnauthorized, k as writeAuthSessionFallbackToken, l as MaybeUnauthenticated, m as useAuthState, n as AuthProvider, o as ConvexProviderWithAuth, p as useAuthGuard, r as Authenticated, s as FetchAccessTokenContext, t as AUTH_SESSION_SYNC_GRACE_MS, u as Unauthenticated, v as useConvexAuthRecovery, w as decodeJwtIdentity, x as useMaybeAuth, y as useFetchAccessToken } from "../auth-store-BHk8eMnX.js";
 import { ConvexProvider, ConvexReactClient, ConvexReactClient as ConvexReactClient$1, useAction, useConvex, useMutation } from "convex/react";
 import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { jsx } from "react/jsx-runtime";
@@ -12,7 +12,7 @@ import { ConvexHttpClient } from "convex/browser";
 //#region src/shared/meta-utils.ts
 const metaCache = /* @__PURE__ */ new WeakMap();
 const nonMetaLeafKeys = new Set(["functionRef", "ref"]);
-function isRecord(value) {
+function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
 function isFunctionType(value) {
@@ -34,10 +34,10 @@ function extractLeafMeta(value) {
 }
 function getHttpRoutes(api) {
 	const routes = api._http;
-	if (!isRecord(routes)) return;
+	if (!isRecord$1(routes)) return;
 	const normalized = {};
 	for (const [routeKey, routeValue] of Object.entries(routes)) {
-		if (!isRecord(routeValue)) continue;
+		if (!isRecord$1(routeValue)) continue;
 		const routePath = routeValue.path;
 		const routeMethod = routeValue.method;
 		if (typeof routePath === "string" && typeof routeMethod === "string") normalized[routeKey] = {
@@ -60,7 +60,7 @@ function buildMetaIndex(api) {
 	const walk = (node, path) => {
 		for (const [key, value] of Object.entries(node)) {
 			if (key.startsWith("_")) continue;
-			if (!isRecord(value)) continue;
+			if (!isRecord$1(value)) continue;
 			const leafMeta = extractLeafMeta(value);
 			if (leafMeta) {
 				if (path.length === 0) continue;
@@ -798,6 +798,49 @@ function createHashFn(fallback = hashKey) {
 	};
 }
 
+//#endregion
+//#region src/internal/shallow.ts
+/**
+* Framework-free shallow comparison helpers.
+*
+* The bindings use these to keep object identity stable across renders when
+* nothing observable changed, so TanStack Query's `shallowEqualObjects` guards
+* and React dependency arrays can actually hit.
+*/
+/** True when `value` is a non-null object. */
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Compare own enumerable string keys with `Object.is`.
+*
+* Deliberately shallow, never deep: option values are frequently closures
+* (`select`, `retry`, function-form `placeholderData`) that capture fresh
+* render scope, and treating a stale closure as equal would serve stale data.
+*/
+function isShallowEqual(a, b) {
+	if (a === b) return true;
+	const keys = Object.keys(a);
+	if (keys.length !== Object.keys(b).length) return false;
+	const left = a;
+	const right = b;
+	for (const key of keys) {
+		if (!Object.hasOwn(right, key)) return false;
+		if (!Object.is(left[key], right[key])) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/internal/use-stable-identity.ts
+function useStableIdentity(value, isEqual = isShallowEqual) {
+	const previousRef = useRef(null);
+	const previous = previousRef.current;
+	if (previous !== null && isEqual(previous, value)) return previous;
+	previousRef.current = value;
+	return value;
+}
+
 //#endregion
 //#region src/react/use-query-options.ts
 /** biome-ignore-all lint/suspicious/noExplicitAny: Convex type compatibility */
@@ -807,22 +850,28 @@ function createHashFn(fallback = hashKey) {
 */
 const EMPTY_ARGS = {};
 const hashConvexOptionsKey = createHashFn();
-const MAX_STABLE_ARGS = 500;
-const stableArgsByHash = /* @__PURE__ */ new Map();
-function getStableArgsByHash(hash, args) {
-	if (stableArgsByHash.has(hash)) {
-		const stableArgs = stableArgsByHash.get(hash);
-		stableArgsByHash.delete(hash);
-		stableArgsByHash.set(hash, stableArgs);
-		return stableArgs;
-	}
-	const stored = structuredClone(args);
-	stableArgsByHash.set(hash, stored);
-	if (stableArgsByHash.size > MAX_STABLE_ARGS) {
-		const oldestHash = stableArgsByHash.keys().next().value;
-		if (oldestHash !== void 0) stableArgsByHash.delete(oldestHash);
+/**
+* Compare two computed option objects for observable equivalence.
+*
+* Top-level values are compared by reference so inline `select` /
+* `placeholderData` closures are never treated as equal. `meta` is exempt: it
+* is rebuilt from scalars by these hooks on every render, so comparing its
+* identity would defeat the whole check.
+*/
+function areQueryOptionsEquivalent(a, b) {
+	const keys = Object.keys(a);
+	if (keys.length !== Object.keys(b).length) return false;
+	const left = a;
+	const right = b;
+	for (const key of keys) {
+		if (!Object.hasOwn(right, key)) return false;
+		const previous = left[key];
+		const next = right[key];
+		if (Object.is(previous, next)) continue;
+		if (key === "meta" && isRecord(previous) && isRecord(next) && isShallowEqual(previous, next)) continue;
+		return false;
 	}
-	return stored;
+	return true;
 }
 function useStableQueryArgs(prefix, funcRef, args) {
 	const resolvedArgs = args === skipToken || args == null ? EMPTY_ARGS : args;
@@ -831,7 +880,7 @@ function useStableQueryArgs(prefix, funcRef, args) {
 		getFunctionName(funcRef),
 		resolvedArgs
 	]);
-	const value = useMemo(() => getStableArgsByHash(argsHash, resolvedArgs), [argsHash, resolvedArgs]);
+	const value = useMemo(() => structuredClone(resolvedArgs), [argsHash]);
 	return useMemo(() => ({
 		hash: argsHash,
 		value
@@ -870,7 +919,7 @@ function useConvexQueryOptions(funcRef, args, options) {
 	});
 	const stableArgs = useStableQueryArgs("convexQuery", funcRef, isSkipped ? EMPTY_ARGS : args);
 	const baseOptions = useMemo(() => convexQuery(funcRef, stableArgs.value), [funcRef, stableArgs]);
-	return useMemo(() => {
+	return useStableIdentity(useMemo(() => {
 		const { enabled: userEnabled, skipUnauth, subscribe, ...queryOptions } = options ?? {};
 		return {
 			...baseOptions,
@@ -889,7 +938,7 @@ function useConvexQueryOptions(funcRef, args, options) {
 		isSkipped,
 		options,
 		shouldSkip
-	]);
+	]), areQueryOptionsEquivalent);
 }
 /**
 * Hook that returns infinite query options for use with useInfiniteQuery.
@@ -965,7 +1014,7 @@ function useConvexActionQueryOptions(action, args, options) {
 	});
 	const stableArgs = useStableQueryArgs("convexAction", action, isSkipped ? EMPTY_ARGS : args);
 	const baseOptions = useMemo(() => convexAction(action, stableArgs.value), [action, stableArgs]);
-	return useMemo(() => {
+	return useStableIdentity(useMemo(() => {
 		const { enabled: userEnabled, skipUnauth, ...queryOptions } = options ?? {};
 		return {
 			...baseOptions,
@@ -983,7 +1032,7 @@ function useConvexActionQueryOptions(action, args, options) {
 		isSkipped,
 		options,
 		shouldSkip
-	]);
+	]), areQueryOptionsEquivalent);
 }
 /**
 * Hook that returns mutation options for use with useMutation.
@@ -1280,6 +1329,17 @@ function useFnMeta() {
 	return (namespace, fnName) => meta?.[namespace]?.[fnName];
 }
 /**
+* Stable signature of the current auth identity.
+*
+* JWTs collapse to their non-volatile claims so a refresh is a no-op; anything
+* that is not a JWT keeps its own signature so opaque-token transitions and
+* logout still register.
+*/
+function resolveAuthIdentity(token) {
+	if (token === null) return null;
+	return decodeJwtIdentity(token) ?? `opaque:${token}`;
+}
+/**
 * Create CRPC context, provider, and hooks for a Convex API.
 *
 * @param options - Configuration object containing api and optional HTTP settings
@@ -1312,7 +1372,6 @@ function createCRPCContext(options) {
 	const meta = buildMetaIndex(api);
 	const CRPCProxyContext = createContext(null);
 	const VanillaClientContext = createContext(null);
-	const HttpProxyContext = createContext(void 0);
 	/** Inner provider */
 	function CRPCProviderInner({ children, convexClient, convexQueryClient }) {
 		const authStore = useAuthStore();
@@ -1323,12 +1382,13 @@ function createCRPCContext(options) {
 		useEffect(() => {
 			const previous = previousAuthRef.current;
 			const tokenReady = token === null || decodeJwtExp(token) !== null;
+			const identity = resolveAuthIdentity(token);
 			previousAuthRef.current = {
 				isAuthenticated,
-				token
+				identity
 			};
 			if (!previous) return;
-			if (tokenReady && (previous.token !== token || previous.isAuthenticated !== isAuthenticated)) convexQueryClient.resetAuthQueries();
+			if (tokenReady && (previous.identity !== identity || previous.isAuthenticated !== isAuthenticated)) convexQueryClient.resetAuthQueries();
 		}, [
 			convexQueryClient,
 			isAuthenticated,
@@ -1363,18 +1423,29 @@ function createCRPCContext(options) {
 		}, [authStore, fetchAccessToken]);
 		const proxy = useMemo(() => createCRPCOptionsProxy(api, meta, options.transformer), []);
 		const vanillaClient = useMemo(() => createVanillaCRPCProxy(api, meta, convexClient, options.transformer), [convexClient]);
+		const mergedProxy = useMemo(() => {
+			if (!httpProxy) return proxy;
+			return new Proxy(proxy, { get(target, prop) {
+				if (prop === "http") return httpProxy;
+				return Reflect.get(target, prop);
+			} });
+		}, [httpProxy, proxy]);
+		const mergedClient = useMemo(() => {
+			if (!httpProxy) return vanillaClient;
+			return new Proxy(vanillaClient, { get(target, prop) {
+				if (prop === "http") return httpProxy;
+				return Reflect.get(target, prop);
+			} });
+		}, [httpProxy, vanillaClient]);
 		return /* @__PURE__ */ jsx(ConvexQueryClientContext.Provider, {
 			value: convexQueryClient,
 			children: /* @__PURE__ */ jsx(MetaContext.Provider, {
 				value: meta,
 				children: /* @__PURE__ */ jsx(VanillaClientContext.Provider, {
-					value: vanillaClient,
-					children: /* @__PURE__ */ jsx(HttpProxyContext.Provider, {
-						value: httpProxy,
-						children: /* @__PURE__ */ jsx(CRPCProxyContext.Provider, {
-							value: proxy,
-							children
-						})
+					value: mergedClient,
+					children: /* @__PURE__ */ jsx(CRPCProxyContext.Provider, {
+						value: mergedProxy,
+						children
 					})
 				})
 			})
@@ -1408,12 +1479,7 @@ function createCRPCContext(options) {
 	*/
 	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;
 	}
 	/**
@@ -1436,12 +1502,7 @@ function createCRPCContext(options) {
 	*/
 	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 {
@@ -1720,6 +1781,19 @@ function isConvexAction(queryKey) {
 	return queryKey.length >= 2 && queryKey[0] === "convexAction";
 }
 /**
+* Write a subscription value into an already-resolved Query.
+*
+* Going through the Query skips the query-key re-hash that the key-based
+* `getQueryData` / `setQueryData` pair pays on every push. `setQueryData`
+* short-circuits on `undefined` and `Query.setData` does not, so the guard has
+* to be reproduced here: without it a never-resolved subscription would flip to
+* `status: 'success'` with `data: undefined`.
+*/
+function writeQueryData(query, value) {
+	if (value === void 0) return;
+	query.setData(value, { manual: true });
+}
+/**
 * Bridges TanStack Query with Convex real-time subscriptions.
 *
 * ## Setup
@@ -1812,15 +1886,12 @@ var ConvexQueryClient = class {
 		const meta = query.meta;
 		return meta?.authType === "required" || meta?.authType === "optional";
 	}
-	isQueryDisabled(query) {
-		return query.isDisabled();
-	}
 	subscribeQuery(query) {
 		if (this.subscriptions[query.queryHash]) return;
 		const meta = query.meta;
 		if (meta?.subscribe === false) return;
 		if (query.getObserversCount() === 0) return;
-		if (this.isQueryDisabled(query)) return;
+		if (query.isDisabled()) return;
 		if (this.shouldSkipSubscription(meta?.authType)) return;
 		const [, funcName, args] = query.queryKey;
 		const watch = this.convexClient.watchQuery(funcName, this.transformer.input.serialize(args));
@@ -1958,15 +2029,15 @@ var ConvexQueryClient = class {
 			};
 		}
 		if (result.ok) {
-			const existingData = this.queryClient.getQueryData(queryKey);
-			if (result.value !== void 0 || !(existingData !== void 0)) this.queryClient.setQueryData(queryKey, this.transformer.output.deserialize(result.value));
+			const existingData = query.state.data;
+			if (result.value !== void 0 || !(existingData !== void 0)) writeQueryData(query, 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));
+				writeQueryData(query, this.transformer.output.deserialize(null));
 				return;
 			}
 			query.setState({
@@ -2023,7 +2094,7 @@ var ConvexQueryClient = class {
 					if (event.action.type === "setState" && event.action.setStateOptions?.meta === "set by ConvexQueryClient") break;
 					break;
 				case "observerOptionsUpdated": {
-					const isDisabled = this.isQueryDisabled(event.query);
+					const isDisabled = event.query.isDisabled();
 					const isSubscribed = !!this.subscriptions[event.query.queryHash];
 					if (isDisabled && isSubscribed) {
 						this.cancelPendingUnsubscribe(event.query.queryHash);
@@ -2289,7 +2360,8 @@ const useStaleCursorRecovery = ({ argsObject, combined, limit, setState, state }
 * Use `useInfiniteQuery` for the public API with auth handling.
 */
 const useInfiniteQueryInternal = (query, args, options) => {
-	const { limit, enabled, placeholderData, ...queryOptions } = options;
+	const { limit, enabled, placeholderData, ...forwardedOptions } = options;
+	const queryOptions = useStableIdentity(forwardedOptions);
 	const { isLoading: isAuthLoading } = useSafeConvexAuth();
 	const meta = useMeta();
 	const queryClient = useQueryClient();
@@ -2433,7 +2505,7 @@ const useInfiniteQueryInternal = (query, args, options) => {
 			prefetchedFirstPage,
 			placeholderData
 		]),
-		combine: (results) => {
+		combine: useCallback((results) => {
 			const allItems = [];
 			const pages = [];
 			const seenIds = /* @__PURE__ */ new Set();
@@ -2474,7 +2546,7 @@ const useInfiniteQueryInternal = (query, args, options) => {
 				isRefetching: isFetching && allItems.length > 0 && !isPlaceholderData,
 				_rawResults: results
 			};
-		}
+		}, [placeholderData])
 	});
 	useStaleCursorRecovery({
 		argsObject,
@@ -2556,6 +2628,13 @@ const useInfiniteQueryInternal = (query, args, options) => {
 		setState,
 		argsObject
 	]);
+	const loadMoreRef = useRef(loadMore);
+	const limitRef = useRef(limit);
+	useEffect(() => {
+		loadMoreRef.current = loadMore;
+		limitRef.current = limit;
+	}, [loadMore, limit]);
+	const fetchNextPage = useCallback((n) => loadMoreRef.current(n ?? limitRef.current), []);
 	const { _rawResults, lastPage, ...result } = combined;
 	const hasNextPage = combined.status === "CanLoadMore";
 	const isFetchingNextPage = combined.status === "LoadingMore";
@@ -2563,7 +2642,7 @@ const useInfiniteQueryInternal = (query, args, options) => {
 		...result,
 		failureReason: combined.failureReason,
 		error: combined.error instanceof Error ? combined.error : null,
-		fetchNextPage: (n) => loadMore(n ?? limit),
+		fetchNextPage,
 		hasNextPage,
 		isFetchingNextPage
 	};
@@ -2608,10 +2687,11 @@ function useInfiniteQuery(infiniteOptions) {
 		queryName,
 		onQueryUnauthorized
 	]);
+	const enabled = useMemo(() => resolveEnabled(!shouldSkip, factoryEnabled), [shouldSkip, factoryEnabled]);
 	const result = useInfiniteQueryInternal(query, args, {
 		limit,
 		...queryOptions,
-		enabled: resolveEnabled(!shouldSkip, factoryEnabled)
+		enabled
 	});
 	const authLoadingApplies = authType === "optional" || authType === "required";
 	const isClientError = isCRPCClientError(result.error);