kitcn 0.15.15 → 0.15.17

package/dist/auth/client/index.d.ts

@@ -1,5 +1,5 @@
 'use client';
-import { r as AuthStore } from "../../auth-store-B_ARzzEX.js";
+import { r as AuthStore } from "../../auth-store-GDNKweSK.js";
 import { ConvexReactClient } from "convex/react";
 import { ReactNode } from "react";
 import * as react_jsx_runtime0 from "react/jsx-runtime";

package/dist/auth/client/index.js

@@ -1,6 +1,6 @@
 'use client';
-import { C as readAuthSessionFallbackData, D as CRPCClientError, O as defaultIsUnauthorized, S as clearAuthSessionFallback, T as writeAuthSessionFallbackData, d as isSessionSyncGraceActive, g as useAuthValue, h as useAuthStore, n as AuthProvider, o as FetchAccessTokenContext, t as AUTH_SESSION_SYNC_GRACE_MS, u as decodeJwtExp, w as readAuthSessionFallbackToken } from "../../auth-store-CwGbvP_s.js";
-import { ConvexProviderWithAuth, useConvexAuth } from "convex/react";
+import { A as defaultIsUnauthorized, D as writeAuthSessionFallbackData, E as readAuthSessionFallbackToken, T as readAuthSessionFallbackData, _ as useAuthValue, d as decodeJwtExp, f as isSessionSyncGraceActive, g as useAuthStore, k as CRPCClientError, n as AuthProvider, o as ConvexProviderWithAuth$1, s as FetchAccessTokenContext, t as AUTH_SESSION_SYNC_GRACE_MS, w as clearAuthSessionFallback } from "../../auth-store-ssZDPa37.js";
+import { useConvexAuth } from "convex/react";
 import { useCallback, useEffect, useMemo, useRef } from "react";
 import { jsx } from "react/jsx-runtime";
 
@@ -272,7 +272,7 @@ function ConvexAuthProviderInner({ children, client, authClient, convexQueryClie
 	}, [fetchAccessToken, authStore]);
 	return /* @__PURE__ */ jsx(FetchAccessTokenContext.Provider, {
 		value: fetchAccessToken,
-		children: /* @__PURE__ */ jsx(ConvexProviderWithAuth, {
+		children: /* @__PURE__ */ jsx(ConvexProviderWithAuth$1, {
 			client,
 			useAuth,
 			children: /* @__PURE__ */ jsx(AuthStateSync, { children })

package/dist/{auth-store-B_ARzzEX.d.ts → auth-store-GDNKweSK.d.ts}

@@ -18,6 +18,23 @@ type ConvexAuthResult = {
 };
 /** Get auth from bridge context (null if no bridge configured) */
 declare const useConvexAuthBridge: () => ConvexAuthResult | null;
+type ConvexAuthRecoveryStatus = 'idle' | 'recovering' | 'failed';
+type ConvexAuthRecoveryErrorCode = 'AUTH_PROVIDER_LOADING' | 'AUTH_PROVIDER_UNAUTHENTICATED' | 'AUTH_RECOVERY_CANCELLED' | 'AUTH_RECOVERY_FAILED' | 'AUTH_RECOVERY_TIMEOUT';
+declare class ConvexAuthRecoveryError extends Error {
+  readonly code: ConvexAuthRecoveryErrorCode;
+  constructor(code: ConvexAuthRecoveryErrorCode, message: string);
+}
+type ConvexAuthRecoveryOptions = {
+  /** Maximum time to wait for Convex backend confirmation. Defaults to 10s. */timeoutMs?: number;
+};
+type ConvexAuthRecovery = {
+  error: ConvexAuthRecoveryError | null;
+  recover: (options?: ConvexAuthRecoveryOptions) => Promise<void>;
+  status: ConvexAuthRecoveryStatus;
+};
+/** Imperatively rebind Convex auth and wait for backend confirmation. */
+declare function useConvexAuthRecovery(): ConvexAuthRecovery;
+type ConvexProviderWithAuthProps = React.ComponentProps<typeof ConvexProviderWithAuth>;
 type AuthStoreState = {
   /** Callback when mutation/action called while unauthorized. Throws by default. */onMutationUnauthorized: () => void; /** Callback when query called while unauthorized. Noop by default. */
   onQueryUnauthorized: (info: {
@@ -116,8 +133,9 @@ declare function ConvexAuthBridge({
  */
 declare function ConvexProviderWithAuth$1({
   children,
-  ...props
-}: React.ComponentProps<typeof ConvexProviderWithAuth>): react_jsx_runtime0.JSX.Element;
+  client,
+  useAuth
+}: ConvexProviderWithAuthProps): react_jsx_runtime0.JSX.Element;
 declare const useAuth: () => {
   hasSession: boolean;
   isAuthenticated: boolean;
@@ -153,4 +171,4 @@ declare function Unauthenticated({
   children: React.ReactNode;
 }): react.ReactNode;
 //#endregion
-export { useMaybeAuth as C, useIsAuth as S, useAuthState as _, Authenticated as a, useConvexAuthBridge as b, FetchAccessTokenContext as c, MaybeUnauthenticated as d, Unauthenticated as f, useAuthGuard as g, useAuth as h, AuthStoreState as i, FetchAccessTokenFn as l, isSessionSyncGraceActive as m, AuthProvider as n, ConvexAuthBridge as o, decodeJwtExp as p, AuthStore as r, ConvexProviderWithAuth$1 as s, AUTH_SESSION_SYNC_GRACE_MS as t, MaybeAuthenticated as u, useAuthStore as v, useSafeConvexAuth as w, useFetchAccessToken as x, useAuthValue as y };
+export { useSafeConvexAuth as A, useAuthStore as C, useFetchAccessToken as D, useConvexAuthRecovery as E, useIsAuth as O, useAuthState as S, useConvexAuthBridge as T, Unauthenticated as _, Authenticated as a, useAuth as b, ConvexAuthRecoveryError as c, ConvexAuthRecoveryStatus as d, ConvexProviderWithAuth$1 as f, MaybeUnauthenticated as g, MaybeAuthenticated as h, AuthStoreState as i, useMaybeAuth as k, ConvexAuthRecoveryErrorCode as l, FetchAccessTokenFn as m, AuthProvider as n, ConvexAuthBridge as o, FetchAccessTokenContext as p, AuthStore as r, ConvexAuthRecovery as s, AUTH_SESSION_SYNC_GRACE_MS as t, ConvexAuthRecoveryOptions as u, decodeJwtExp as v, useAuthValue as w, useAuthGuard as x, isSessionSyncGraceActive as y };

package/dist/{auth-store-CwGbvP_s.js → auth-store-ssZDPa37.js}

@@ -1,8 +1,8 @@
 'use client';
 import { ConvexProviderWithAuth, useConvexAuth } from "convex/react";
-import { createContext, useContext } from "react";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
 import { createAtomStore } from "jotai-x";
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
 
 //#region src/crpc/error.ts
 /**
@@ -102,6 +102,69 @@ const useFetchAccessToken = () => useContext(FetchAccessTokenContext);
 const ConvexAuthBridgeContext = createContext(null);
 /** Get auth from bridge context (null if no bridge configured) */
 const useConvexAuthBridge = () => useContext(ConvexAuthBridgeContext);
+var ConvexAuthRecoveryError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "ConvexAuthRecoveryError";
+		this.code = code;
+	}
+};
+const ConvexAuthRecoveryContext = createContext(null);
+/** Imperatively rebind Convex auth and wait for backend confirmation. */
+function useConvexAuthRecovery() {
+	const recovery = useContext(ConvexAuthRecoveryContext);
+	if (!recovery) throw new Error("useConvexAuthRecovery must be used inside ConvexProviderWithAuth");
+	return recovery;
+}
+const AUTH_RECOVERY_TIMEOUT_MS = 1e4;
+function ConvexAuthRecoverySync({ authProviderAuthenticated, authProviderLoading, onChange }) {
+	const auth = useConvexAuth();
+	useEffect(() => {
+		onChange({
+			authProviderAuthenticated,
+			authProviderLoading,
+			isAuthenticated: auth.isAuthenticated,
+			isLoading: auth.isLoading
+		});
+	}, [
+		auth.isAuthenticated,
+		auth.isLoading,
+		authProviderAuthenticated,
+		authProviderLoading,
+		onChange
+	]);
+	return null;
+}
+function ConvexAuthBinding({ bindingVersion, children, client, onAuthSnapshot, onBindingFetch, useAuth }) {
+	const { fetchAccessToken: fetchAccessTokenFromAuth, isAuthenticated, isLoading } = useAuth();
+	const fetchAccessToken = useCallback((args) => {
+		onBindingFetch(bindingVersion);
+		return fetchAccessTokenFromAuth(args);
+	}, [
+		bindingVersion,
+		fetchAccessTokenFromAuth,
+		onBindingFetch
+	]);
+	const boundAuth = useMemo(() => ({
+		fetchAccessToken,
+		isAuthenticated,
+		isLoading
+	}), [
+		fetchAccessToken,
+		isAuthenticated,
+		isLoading
+	]);
+	return /* @__PURE__ */ jsxs(ConvexProviderWithAuth, {
+		client,
+		useAuth: useCallback(() => boundAuth, [boundAuth]),
+		children: [/* @__PURE__ */ jsx(ConvexAuthRecoverySync, {
+			authProviderAuthenticated: isAuthenticated,
+			authProviderLoading: isLoading,
+			onChange: onAuthSnapshot
+		}), /* @__PURE__ */ jsx(ConvexAuthBridge, { children })]
+	});
+}
 const AUTH_SESSION_SYNC_GRACE_MS = 1e4;
 const isSessionSyncGraceActive = (sessionSyncGraceUntil) => typeof sessionSyncGraceUntil === "number" && sessionSyncGraceUntil > Date.now();
 /** Decode JWT expiration (ms timestamp) from token */
@@ -176,10 +239,123 @@ function ConvexAuthBridge({ children }) {
 * </ConvexProviderWithAuth>
 * ```
 */
-function ConvexProviderWithAuth$1({ children, ...props }) {
-	return /* @__PURE__ */ jsx(ConvexProviderWithAuth, {
-		...props,
-		children: /* @__PURE__ */ jsx(ConvexAuthBridge, { children })
+function ConvexProviderWithAuth$1({ children, client, useAuth }) {
+	const [bindingVersion, setBindingVersion] = useState(0);
+	const [error, setError] = useState(null);
+	const [status, setStatus] = useState("idle");
+	const bindingVersionRef = useRef(0);
+	const pendingRef = useRef(null);
+	const authSnapshotRef = useRef({
+		authProviderAuthenticated: false,
+		authProviderLoading: true,
+		isAuthenticated: false,
+		isLoading: true
+	});
+	const settleRecovery = useCallback((recoveryError) => {
+		const pending = pendingRef.current;
+		if (!pending) return;
+		clearTimeout(pending.timeoutId);
+		pendingRef.current = null;
+		if (recoveryError) {
+			setError(recoveryError);
+			setStatus("failed");
+			pending.reject(recoveryError);
+			return;
+		}
+		setError(null);
+		setStatus("idle");
+		pending.resolve();
+	}, []);
+	const onAuthSnapshot = useCallback((snapshot) => {
+		authSnapshotRef.current = snapshot;
+		const pending = pendingRef.current;
+		if (!pending) return;
+		if (snapshot.authProviderLoading) {
+			settleRecovery(new ConvexAuthRecoveryError("AUTH_PROVIDER_LOADING", "Cannot recover Convex auth while the auth provider is loading"));
+			return;
+		}
+		if (!snapshot.authProviderAuthenticated) {
+			settleRecovery(new ConvexAuthRecoveryError("AUTH_PROVIDER_UNAUTHENTICATED", "Cannot recover Convex auth without an authenticated provider session"));
+			return;
+		}
+		if (!pending.isBound || snapshot.isLoading) return;
+		if (snapshot.isAuthenticated) {
+			settleRecovery(null);
+			return;
+		}
+		settleRecovery(new ConvexAuthRecoveryError("AUTH_RECOVERY_FAILED", "Convex rejected the recovered authentication binding"));
+	}, [settleRecovery]);
+	const onBindingFetch = useCallback((activeBindingVersion) => {
+		const pending = pendingRef.current;
+		if (pending?.bindingVersion === activeBindingVersion) pending.isBound = true;
+	}, []);
+	const recover = useCallback((options = {}) => {
+		const pending = pendingRef.current;
+		if (pending) return pending.promise;
+		const authSnapshot = authSnapshotRef.current;
+		if (authSnapshot.authProviderLoading) {
+			const recoveryError = new ConvexAuthRecoveryError("AUTH_PROVIDER_LOADING", "Cannot recover Convex auth while the auth provider is loading");
+			setError(recoveryError);
+			setStatus("failed");
+			return Promise.reject(recoveryError);
+		}
+		if (!authSnapshot.authProviderAuthenticated) {
+			const recoveryError = new ConvexAuthRecoveryError("AUTH_PROVIDER_UNAUTHENTICATED", "Cannot recover Convex auth without an authenticated provider session");
+			setError(recoveryError);
+			setStatus("failed");
+			return Promise.reject(recoveryError);
+		}
+		let resolve;
+		let reject;
+		const promise = new Promise((resolvePromise, rejectPromise) => {
+			resolve = resolvePromise;
+			reject = rejectPromise;
+		});
+		const timeoutMs = options.timeoutMs ?? AUTH_RECOVERY_TIMEOUT_MS;
+		const nextBindingVersion = bindingVersionRef.current + 1;
+		const timeoutId = setTimeout(() => {
+			settleRecovery(new ConvexAuthRecoveryError("AUTH_RECOVERY_TIMEOUT", `Convex auth recovery timed out after ${timeoutMs}ms`));
+		}, timeoutMs);
+		pendingRef.current = {
+			bindingVersion: nextBindingVersion,
+			isBound: false,
+			promise,
+			reject,
+			resolve,
+			timeoutId
+		};
+		bindingVersionRef.current = nextBindingVersion;
+		setError(null);
+		setStatus("recovering");
+		setBindingVersion(nextBindingVersion);
+		return promise;
+	}, [settleRecovery]);
+	useEffect(() => () => {
+		const pending = pendingRef.current;
+		if (!pending) return;
+		clearTimeout(pending.timeoutId);
+		pendingRef.current = null;
+		pending.reject(new ConvexAuthRecoveryError("AUTH_RECOVERY_CANCELLED", "Convex auth recovery was cancelled because the provider unmounted"));
+	}, []);
+	const recovery = useMemo(() => ({
+		error,
+		recover,
+		status
+	}), [
+		error,
+		recover,
+		status
+	]);
+	return /* @__PURE__ */ jsx(ConvexAuthRecoveryContext.Provider, {
+		value: recovery,
+		children: /* @__PURE__ */ jsx(ConvexAuthBinding, {
+			bindingVersion,
+			client,
+			onAuthSnapshot,
+			onBindingFetch,
+			useAuth,
+			children
+		})
 	});
 }
 const useAuth = () => {
@@ -251,4 +427,4 @@ function Unauthenticated({ children }) {
 }
 
 //#endregion
-export { readAuthSessionFallbackData as C, CRPCClientError as D, writeAuthSessionFallbackToken as E, defaultIsUnauthorized as O, clearAuthSessionFallback as S, writeAuthSessionFallbackData as T, useConvexAuthBridge as _, ConvexProviderWithAuth$1 as a, useMaybeAuth as b, MaybeUnauthenticated as c, isSessionSyncGraceActive as d, useAuth as f, useAuthValue as g, useAuthStore as h, ConvexAuthBridge as i, isCRPCClientError as k, Unauthenticated as l, useAuthState as m, AuthProvider as n, FetchAccessTokenContext as o, useAuthGuard as p, Authenticated as r, MaybeAuthenticated as s, AUTH_SESSION_SYNC_GRACE_MS as t, decodeJwtExp as u, useFetchAccessToken as v, readAuthSessionFallbackToken as w, useSafeConvexAuth as x, useIsAuth as y };
+export { defaultIsUnauthorized as A, useSafeConvexAuth as C, writeAuthSessionFallbackData as D, readAuthSessionFallbackToken as E, writeAuthSessionFallbackToken as O, useMaybeAuth as S, readAuthSessionFallbackData as T, useAuthValue as _, ConvexAuthRecoveryError as a, useFetchAccessToken as b, MaybeAuthenticated as c, decodeJwtExp as d, isSessionSyncGraceActive as f, useAuthStore as g, useAuthState as h, ConvexAuthBridge as i, isCRPCClientError as j, CRPCClientError as k, MaybeUnauthenticated as l, useAuthGuard as m, AuthProvider as n, ConvexProviderWithAuth$1 as o, useAuth as p, Authenticated as r, FetchAccessTokenContext as s, AUTH_SESSION_SYNC_GRACE_MS as t, Unauthenticated as u, useConvexAuthBridge as v, clearAuthSessionFallback as w, useIsAuth as x, useConvexAuthRecovery as y };

package/dist/react/index.d.ts

@@ -1,5 +1,5 @@
 'use client';
-import { C as useMaybeAuth, S as useIsAuth, _ as useAuthState, a as Authenticated, b as useConvexAuthBridge, c as FetchAccessTokenContext, d as MaybeUnauthenticated, f as Unauthenticated, g as useAuthGuard, h as useAuth, i as AuthStoreState, l as FetchAccessTokenFn, m as isSessionSyncGraceActive, n as AuthProvider, o as ConvexAuthBridge, p as decodeJwtExp, r as AuthStore, s as ConvexProviderWithAuth, t as AUTH_SESSION_SYNC_GRACE_MS, u as MaybeAuthenticated, v as useAuthStore, w as useSafeConvexAuth, x as useFetchAccessToken, y as useAuthValue } from "../auth-store-B_ARzzEX.js";
+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 { 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";
@@ -1143,4 +1143,4 @@ declare function useUploadMutationOptions<TGenerateUrlMutation extends FunctionR
  */
 declare function createVanillaCRPCProxy<TApi extends Record<string, unknown>>(api: TApi, meta: CallerMeta, convexClient: ConvexReactClient$1, transformer?: DataTransformerOptions): VanillaCRPCClient<TApi>;
 //#endregion
-export { AUTH_SESSION_SYNC_GRACE_MS, AuthMutationError, AuthProvider, AuthStore, AuthStoreState, Authenticated, CRPCHttpOptions, ConvexAuthBridge, ConvexProvider, ConvexProviderWithAuth, ConvexQueryClient, ConvexQueryClientOptions, ConvexQueryClientSingletonOptions, ConvexReactClient, CreateCRPCContextOptions, FetchAccessTokenContext, FetchAccessTokenFn, HttpCRPCClient, HttpCRPCClientFromRouter, type HttpClientOptions, type HttpFormValue, type HttpInputArgs, HttpMutationKey, HttpProxyOptions, HttpQueryKey, HttpRouteInfo, HttpRouteMap, MaybeAuthenticated, MaybeUnauthenticated, PaginationState, PaginationStatus, Unauthenticated, UseInfiniteQueryResult, VanillaHttpCRPCClient, VanillaHttpCRPCClientFromRouter, createAuthMutations, createCRPCContext, createCRPCOptionsProxy, createHttpProxy, createVanillaCRPCProxy, decodeJwtExp, getConvexQueryClientSingleton, getQueryClientSingleton, isAuthMutationError, isSessionSyncGraceActive, useAuth, useAuthGuard, useAuthState, useAuthStore, useAuthValue, useConvex, useConvexActionOptions, useConvexActionQueryOptions, useSafeConvexAuth as useConvexAuth, useSafeConvexAuth, useConvexAuthBridge, useConvexInfiniteQueryOptions, useConvexMutationOptions, useConvexQueryClient, useConvexQueryOptions, useFetchAccessToken, useFnMeta, useInfiniteQuery, useIsAuth, useMaybeAuth, useMeta, useUploadMutationOptions };
+export { AUTH_SESSION_SYNC_GRACE_MS, AuthMutationError, AuthProvider, AuthStore, AuthStoreState, Authenticated, CRPCHttpOptions, ConvexAuthBridge, ConvexAuthRecovery, ConvexAuthRecoveryError, ConvexAuthRecoveryErrorCode, ConvexAuthRecoveryOptions, ConvexAuthRecoveryStatus, ConvexProvider, ConvexProviderWithAuth, ConvexQueryClient, ConvexQueryClientOptions, ConvexQueryClientSingletonOptions, ConvexReactClient, CreateCRPCContextOptions, FetchAccessTokenContext, FetchAccessTokenFn, HttpCRPCClient, HttpCRPCClientFromRouter, type HttpClientOptions, type HttpFormValue, type HttpInputArgs, HttpMutationKey, HttpProxyOptions, HttpQueryKey, HttpRouteInfo, HttpRouteMap, MaybeAuthenticated, MaybeUnauthenticated, PaginationState, PaginationStatus, Unauthenticated, UseInfiniteQueryResult, VanillaHttpCRPCClient, VanillaHttpCRPCClientFromRouter, createAuthMutations, createCRPCContext, createCRPCOptionsProxy, createHttpProxy, createVanillaCRPCProxy, decodeJwtExp, getConvexQueryClientSingleton, getQueryClientSingleton, isAuthMutationError, isSessionSyncGraceActive, useAuth, useAuthGuard, useAuthState, useAuthStore, useAuthValue, useConvex, useConvexActionOptions, useConvexActionQueryOptions, useSafeConvexAuth as useConvexAuth, useSafeConvexAuth, useConvexAuthBridge, useConvexAuthRecovery, useConvexInfiniteQueryOptions, useConvexMutationOptions, useConvexQueryClient, useConvexQueryOptions, useFetchAccessToken, useFnMeta, useInfiniteQuery, useIsAuth, useMaybeAuth, useMeta, useUploadMutationOptions };

package/dist/react/index.js

@@ -1,5 +1,5 @@
 'use client';
-import { D as CRPCClientError, E as writeAuthSessionFallbackToken, O as defaultIsUnauthorized, S as clearAuthSessionFallback, T as writeAuthSessionFallbackData, _ as useConvexAuthBridge, a as ConvexProviderWithAuth, b as useMaybeAuth, c as MaybeUnauthenticated, d as isSessionSyncGraceActive, f as useAuth, g as useAuthValue, h as useAuthStore, i as ConvexAuthBridge, k as isCRPCClientError, l as Unauthenticated, m as useAuthState, n as AuthProvider, o as FetchAccessTokenContext, p as useAuthGuard, r as Authenticated, s as MaybeAuthenticated, t as AUTH_SESSION_SYNC_GRACE_MS, u as decodeJwtExp, v as useFetchAccessToken, x as useSafeConvexAuth, y as useIsAuth } from "../auth-store-CwGbvP_s.js";
+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-ssZDPa37.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";
@@ -2159,6 +2159,10 @@ const getConvexQueryClientSingleton = ({ authStore, convex, queryClient, symbolK
 	return client;
 };
 
+//#endregion
+//#region src/internal/pagination.ts
+const shouldSplitPaginationPage = (page, initialNumItems) => Boolean(page.splitCursor) && (page.pageStatus === "SplitRecommended" || page.pageStatus === "SplitRequired" || initialNumItems !== void 0 && page.page.length > initialNumItems * 2);
+
 //#endregion
 //#region src/react/use-infinite-query.ts
 /** biome-ignore-all lint/suspicious/noExplicitAny: Convex query/mutation type compatibility */
@@ -2453,7 +2457,7 @@ const useInfiniteQueryInternal = (query, args, options) => {
 				const page = pageQuery.data;
 				const pageKey = state.pageKeys[i];
 				const pageState = state.queries[pageKey];
-				if (page.splitCursor && pageState && !pageState.endCursor) {
+				if (shouldSplitPaginationPage(page, limit) && pageState && !pageState.endCursor) {
 					setState((prev) => {
 						const currentPageState = prev.queries[pageKey];
 						if (!currentPageState || currentPageState.endCursor) return prev;
@@ -2491,6 +2495,7 @@ const useInfiniteQueryInternal = (query, args, options) => {
 		state.pageKeys,
 		state.queries,
 		argsObject,
+		limit,
 		setState
 	]);
 	const loadMore = useCallback((pageLimit) => {
@@ -2592,4 +2597,4 @@ function useInfiniteQuery(infiniteOptions) {
 }
 
 //#endregion
-export { AUTH_SESSION_SYNC_GRACE_MS, AuthMutationError, AuthProvider, Authenticated, ConvexAuthBridge, ConvexProvider, ConvexProviderWithAuth, ConvexQueryClient, ConvexReactClient, FetchAccessTokenContext, MaybeAuthenticated, MaybeUnauthenticated, Unauthenticated, createAuthMutations, createCRPCContext, createCRPCOptionsProxy, createHttpProxy, createVanillaCRPCProxy, decodeJwtExp, getConvexQueryClientSingleton, getQueryClientSingleton, isAuthMutationError, isSessionSyncGraceActive, useAuth, useAuthGuard, useAuthState, useAuthStore, useAuthValue, useConvex, useConvexActionOptions, useConvexActionQueryOptions, useSafeConvexAuth as useConvexAuth, useSafeConvexAuth, useConvexAuthBridge, useConvexInfiniteQueryOptions, useConvexMutationOptions, useConvexQueryClient, useConvexQueryOptions, useFetchAccessToken, useFnMeta, useInfiniteQuery, useIsAuth, useMaybeAuth, useMeta, useUploadMutationOptions };
+export { AUTH_SESSION_SYNC_GRACE_MS, AuthMutationError, AuthProvider, Authenticated, ConvexAuthBridge, ConvexAuthRecoveryError, ConvexProvider, ConvexProviderWithAuth, ConvexQueryClient, ConvexReactClient, FetchAccessTokenContext, MaybeAuthenticated, MaybeUnauthenticated, Unauthenticated, createAuthMutations, createCRPCContext, createCRPCOptionsProxy, createHttpProxy, createVanillaCRPCProxy, decodeJwtExp, getConvexQueryClientSingleton, getQueryClientSingleton, isAuthMutationError, isSessionSyncGraceActive, useAuth, useAuthGuard, useAuthState, useAuthStore, useAuthValue, useConvex, useConvexActionOptions, useConvexActionQueryOptions, useSafeConvexAuth as useConvexAuth, useSafeConvexAuth, useConvexAuthBridge, useConvexAuthRecovery, useConvexInfiniteQueryOptions, useConvexMutationOptions, useConvexQueryClient, useConvexQueryOptions, useFetchAccessToken, useFnMeta, useInfiniteQuery, useIsAuth, useMaybeAuth, useMeta, useUploadMutationOptions };

package/dist/solid/index.js

@@ -2486,6 +2486,10 @@ const getConvexQueryClientSingleton = ({ authStore, convex, queryClient, symbolK
 	return client;
 };
 
+//#endregion
+//#region src/internal/pagination.ts
+const shouldSplitPaginationPage = (page, initialNumItems) => Boolean(page.splitCursor) && (page.pageStatus === "SplitRecommended" || page.pageStatus === "SplitRequired" || initialNumItems !== void 0 && page.page.length > initialNumItems * 2);
+
 //#endregion
 //#region src/solid/use-infinite-query.ts
 const PAGINATION_KEY_PREFIX = "__pagination__";
@@ -2757,7 +2761,7 @@ const useInfiniteQueryInternal = (query, args, options) => {
 				const page = pageQuery.data;
 				const pageKey = state().pageKeys[i];
 				const pageState = state().queries[pageKey];
-				if (page.splitCursor && pageState && !pageState.endCursor) {
+				if (shouldSplitPaginationPage(page, limit) && pageState && !pageState.endCursor) {
 					setState((prev) => {
 						const currentPageState = prev.queries[pageKey];
 						if (!currentPageState || currentPageState.endCursor) return prev;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kitcn",
-  "version": "0.15.15",
+  "version": "0.15.17",
   "description": "kitcn - React Query integration and CLI tools for Convex",
   "keywords": [
     "convex",

package/skills/kitcn/references/features/auth.md

@@ -358,6 +358,7 @@ All from `kitcn/react`:
 | `useMaybeAuth()` | `boolean` | Has token (optimistic, may not be verified) |
 | `useIsAuth()` | `boolean` | Server-verified authentication |
 | `useAuthGuard()` | `() => boolean` | Guard mutations, returns true if blocked |
+| `useConvexAuthRecovery()` | `{ recover, status, error }` | Rebind Convex auth after a transient token failure |
 
 ### useAuthGuard
 
@@ -409,6 +410,28 @@ import { ConvexProviderWithAuth } from 'kitcn/react';
 <ConvexProviderWithAuth client={convex} useAuth={useAuthFromConvexDev}>
 ```
 
+### Convex Auth Recovery
+
+Use recovery only when the outer auth provider remains authenticated but
+Convex entered an unauthenticated state after a transient token refresh
+failure:
+
+```tsx
+import { useConvexAuthRecovery } from 'kitcn/react';
+
+const { error, recover, status } = useConvexAuthRecovery();
+await recover();
+```
+
+`recover()` replaces the provider-owned auth binding and resolves after Convex
+confirms authentication. Concurrent calls share one promise. The default
+timeout is 10 seconds; override it with `recover({ timeoutMs })`.
+
+Failures are `ConvexAuthRecoveryError` values with code
+`AUTH_PROVIDER_LOADING`, `AUTH_PROVIDER_UNAUTHENTICATED`,
+`AUTH_RECOVERY_CANCELLED`, `AUTH_RECOVERY_FAILED`, or
+`AUTH_RECOVERY_TIMEOUT`. Never recover an intentional sign-out.
+
 ---
 
 ## Auth Triggers