kitcn 0.16.0 → 0.17.0

package/dist/ratelimit/react/index.d.ts

@@ -2,11 +2,25 @@
 import { FunctionReference } from "convex/server";
 
 //#region src/ratelimit/types.d.ts
+type RatelimitStoredState = {
+  value: number;
+  ts: number;
+  auxValue?: number;
+  auxTs?: number;
+};
+type RatelimitShardState = {
+  shard: number;
+  state: RatelimitStoredState;
+};
+type RatelimitState = RatelimitStoredState & {
+  shards?: RatelimitShardState[];
+};
 type RatelimitSnapshot = {
   value: number;
   ts: number;
   shard: number;
   config: ResolvedAlgorithm;
+  state: RatelimitState;
 };
 type FixedWindowAlgorithm = {
   kind: 'fixedWindow';

package/dist/ratelimit/react/index.js

@@ -3,12 +3,134 @@ import { useConvex, useQuery } from "convex/react";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { makeFunctionReference } from "convex/server";
 
+//#region src/ratelimit/core/algorithms.ts
+/**
+* Narrow the configured budget down to the slice one shard owns.
+*
+* Every shard stores its own row and spends only what it owns, so without this
+* the effective limit would be multiplied by the shard count. Shares are dealt
+* so they add back up to the configured budget exactly — see {@link shardShare}.
+*/
+function shardAlgorithm(algorithm, shard) {
+	const { shards } = algorithm;
+	if (shards <= 1) return algorithm;
+	const share = (value) => shardShare(value, shards, shard);
+	const maxReserved = algorithm.maxReserved === void 0 ? void 0 : share(algorithm.maxReserved);
+	if (algorithm.kind === "tokenBucket") {
+		const maxTokens = share(algorithm.maxTokens);
+		return {
+			...algorithm,
+			refillRate: algorithm.refillRate * (maxTokens / algorithm.maxTokens),
+			maxTokens,
+			maxReserved,
+			shards: 1
+		};
+	}
+	if (algorithm.kind === "fixedWindow") return {
+		...algorithm,
+		limit: share(algorithm.limit),
+		capacity: share(algorithm.capacity),
+		maxReserved,
+		shards: 1
+	};
+	return {
+		...algorithm,
+		limit: share(algorithm.limit),
+		maxReserved,
+		shards: 1
+	};
+}
+/** Tokens a shard-level config may spend, ignoring the per-window refill. */
+function algorithmBudget(algorithm) {
+	return algorithm.kind === "tokenBucket" ? algorithm.maxTokens : algorithm.limit;
+}
+/** Tokens the algorithm can hold, including fixed-window burst capacity. */
+function algorithmCapacity(algorithm) {
+	if (algorithm.kind === "fixedWindow") return algorithm.capacity;
+	return algorithmBudget(algorithm);
+}
+/**
+* Deal a whole-token budget across `shards` so the shares sum back to `total`.
+*
+* A plain `total / shards` strands the fractional part of every shard: a shard
+* holding `2.5` tokens only ever grants two whole requests and refills to `2.5`
+* again, so `limit: 5` over two shards would enforce `4` forever. Whole budgets
+* are dealt as `floor` plus one extra token to the first `total % shards` shards
+* instead. Fractional budgets have no whole-token floor to hit, so they keep the
+* even split.
+*/
+function shardShare(total, shards, shard) {
+	const whole = Math.floor(total);
+	const fractional = total - whole;
+	return Math.floor(whole / shards) + (shard < whole % shards ? 1 : 0) + (shard === 0 ? fractional : 0);
+}
+
+//#endregion
 //#region src/ratelimit/core/calculate-rate-limit.ts
 function calculateRatelimit(state, algorithm, now, count) {
+	const shardStates = state?.shards;
+	if (algorithm.shards > 1 && count > maximumShardCapacity(algorithm)) return {
+		...calculateSingleRatelimit(state, algorithm, now, count),
+		retryAfter: Number.POSITIVE_INFINITY,
+		reset: Number.POSITIVE_INFINITY
+	};
+	if (algorithm.shards > 1 && shardStates?.length === algorithm.shards) return calculateShardedRatelimit(shardStates, algorithm, now, count);
+	return calculateSingleRatelimit(state, algorithm, now, count);
+}
+function calculateSingleRatelimit(state, algorithm, now, count) {
 	if (algorithm.kind === "fixedWindow") return calculateFixedWindow(state, algorithm, now, count);
 	if (algorithm.kind === "tokenBucket") return calculateTokenBucket(state, algorithm, now, count);
 	return calculateSlidingWindow(state, algorithm, now, count);
 }
+function maximumShardCapacity(algorithm) {
+	let maximum = 0;
+	for (let shard = 0; shard < algorithm.shards; shard += 1) maximum = Math.max(maximum, algorithmCapacity(shardAlgorithm(algorithm, shard)));
+	return maximum;
+}
+function calculateShardedRatelimit(shardStates, algorithm, now, count) {
+	const candidates = shardStates.map(({ shard, state: shardState }) => {
+		const perShard = shardAlgorithm(algorithm, shard);
+		return {
+			baseline: calculateRatelimit(shardState, perShard, now, 0),
+			requested: calculateRatelimit(shardState, perShard, now, count),
+			shard
+		};
+	});
+	const selected = [...count === 0 ? candidates : candidates.filter((candidate) => candidate.requested.retryAfter === void 0)].sort((a, b) => b.requested.remainingRaw - a.requested.remainingRaw)[0];
+	const projected = candidates.map((candidate) => ({
+		evaluated: count !== 0 && candidate.shard === selected?.shard ? candidate.requested : candidate.baseline,
+		shard: candidate.shard
+	}));
+	const retryValues = candidates.flatMap((candidate) => candidate.requested.retryAfter === void 0 ? [] : [candidate.requested.retryAfter]);
+	const retryAfter = selected ? void 0 : Math.min(...retryValues);
+	const remaining = selected ? projected.reduce((total, candidate) => total + candidate.evaluated.remaining, 0) : 0;
+	const remainingRaw = selected ? projected.reduce((total, candidate) => total + Math.max(0, candidate.evaluated.remainingRaw), 0) : Math.max(...candidates.map((candidate) => candidate.requested.remainingRaw));
+	const auxTimestamps = projected.flatMap((candidate) => candidate.evaluated.state.auxTs === void 0 ? [] : [candidate.evaluated.state.auxTs]);
+	return {
+		state: {
+			value: selected || count === 0 ? projected.reduce((total, candidate) => total + candidate.evaluated.state.value, 0) : remainingRaw,
+			ts: Math.max(...projected.map((candidate) => candidate.evaluated.state.ts)),
+			...auxTimestamps.length > 0 ? {
+				auxValue: projected.reduce((total, candidate) => total + (candidate.evaluated.state.auxValue ?? 0), 0),
+				auxTs: Math.max(...auxTimestamps)
+			} : {},
+			shards: projected.map(({ evaluated, shard }) => ({
+				shard,
+				state: {
+					value: evaluated.state.value,
+					ts: evaluated.state.ts,
+					auxValue: evaluated.state.auxValue,
+					auxTs: evaluated.state.auxTs
+				}
+			}))
+		},
+		retryAfter,
+		remaining,
+		remainingRaw,
+		reset: Math.min(...candidates.map((candidate) => candidate.requested.reset)),
+		limit: algorithmBudget(algorithm)
+	};
+}
 function calculateTokenBucket(state, config, now, count) {
 	const ratePerMs = config.refillRate / config.interval;
 	const initial = state ?? {
@@ -17,7 +139,8 @@ function calculateTokenBucket(state, config, now, count) {
 	};
 	const elapsed = Math.max(0, now - initial.ts);
 	const nextValue = Math.min(initial.value + elapsed * ratePerMs, config.maxTokens) - count;
-	const retryAfter = nextValue < 0 ? Math.ceil(-nextValue / ratePerMs) : void 0;
+	let retryAfter;
+	if (nextValue < 0) retryAfter = count > config.maxTokens ? Number.POSITIVE_INFINITY : Math.ceil(-nextValue / ratePerMs);
 	return {
 		state: {
 			value: nextValue,
@@ -25,6 +148,7 @@ function calculateTokenBucket(state, config, now, count) {
 		},
 		retryAfter,
 		remaining: Math.max(0, Math.floor(nextValue)),
+		remainingRaw: nextValue,
 		reset: retryAfter ? now + retryAfter : now,
 		limit: config.maxTokens
 	};
@@ -39,7 +163,8 @@ function calculateFixedWindow(state, config, now, count) {
 	const replenished = Math.min(initial.value + config.limit * elapsedWindows, config.capacity);
 	const ts = initial.ts + elapsedWindows * config.window;
 	const nextValue = replenished - count;
-	const retryAfter = nextValue < 0 ? ts + config.window * Math.ceil(-nextValue / config.limit) - now : void 0;
+	let retryAfter;
+	if (nextValue < 0) retryAfter = count > config.capacity ? Number.POSITIVE_INFINITY : ts + config.window * Math.ceil(-nextValue / config.limit) - now;
 	return {
 		state: {
 			value: nextValue,
@@ -47,7 +172,8 @@ function calculateFixedWindow(state, config, now, count) {
 		},
 		retryAfter,
 		remaining: Math.max(0, Math.floor(nextValue)),
-		reset: ts + config.window,
+		remainingRaw: nextValue,
+		reset: retryAfter === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : ts + config.window,
 		limit: config.limit
 	};
 }
@@ -67,7 +193,8 @@ function calculateSlidingWindow(state, config, now, count) {
 	const projectedCurrent = currentCount + count;
 	const projectedUsed = projectedCurrent + previousCount * previousWeight;
 	const remaining = config.limit - projectedUsed;
-	const retryAfter = remaining < 0 ? Math.max(1, config.window - elapsedInWindow) : void 0;
+	let retryAfter;
+	if (remaining < 0) retryAfter = count > config.limit ? Number.POSITIVE_INFINITY : Math.max(1, config.window - elapsedInWindow);
 	return {
 		state: {
 			value: projectedCurrent,
@@ -77,10 +204,22 @@ function calculateSlidingWindow(state, config, now, count) {
 		},
 		retryAfter,
 		remaining: Math.max(0, Math.floor(remaining)),
-		reset: windowStart + config.window,
+		remainingRaw: remaining,
+		reset: retryAfter === Number.POSITIVE_INFINITY ? Number.POSITIVE_INFINITY : windowStart + config.window,
 		limit: config.limit
 	};
 }
+/**
+* Convert a {@link RatelimitSnapshot} back into the `RatelimitState` shape that
+* {@link calculateRatelimit} consumes.
+*
+* Snapshot `value` is always "tokens left". Fixed window and token bucket store
+* that directly, but sliding window state stores the used count, so it has to be
+* inverted before it can be replayed.
+*/
+function snapshotToState(snapshot) {
+	return { ...snapshot.state };
+}
 function alignWindowStart(now, window, start = 0) {
 	const offsetNow = now - start;
 	return start + Math.floor(offsetNow / window) * window;
@@ -116,8 +255,8 @@ function useRatelimit(getRatelimitValueQuery, options) {
 			ts: evaluation.ts - timeOffset,
 			config: ratelimitData.config,
 			shard: ratelimitData.shard,
-			ok: evaluation.value >= 0,
-			retryAt: evaluation.retryAfter ? serverTs + evaluation.retryAfter - timeOffset : void 0
+			ok: evaluation.retryAfter === void 0,
+			retryAt: evaluation.retryAfter === void 0 ? void 0 : serverTs + evaluation.retryAfter - timeOffset
 		};
 	}, [
 		count,
@@ -130,7 +269,7 @@ function useRatelimit(getRatelimitValueQuery, options) {
 			status: void 0,
 			check
 		};
-		if (current.value < 0) return {
+		if (!current.ok) return {
 			status: {
 				ok: false,
 				retryAt: current.retryAt
@@ -146,7 +285,7 @@ function useRatelimit(getRatelimitValueQuery, options) {
 		};
 	}, [check, current]);
 	useEffect(() => {
-		if (response.status?.ok !== false || !response.status.retryAt) return;
+		if (response.status?.ok !== false || !response.status.retryAt || !Number.isFinite(response.status.retryAt)) return;
 		const timeout = setTimeout(() => setNow(Date.now()), Math.max(0, response.status.retryAt - now));
 		return () => clearTimeout(timeout);
 	}, [
@@ -165,13 +304,7 @@ function resolveGetServerTimeMutation(ref) {
 	return ref;
 }
 function evaluateSnapshot(snapshot, now, count) {
-	const evaluated = calculateRatelimit(snapshot.config.kind === "slidingWindow" ? {
-		value: Math.max(0, snapshot.config.limit - snapshot.value),
-		ts: snapshot.ts
-	} : {
-		value: snapshot.value,
-		ts: snapshot.ts
-	}, snapshot.config, now, count);
+	const evaluated = calculateRatelimit(snapshotToState(snapshot), snapshot.config, now, count);
 	return {
 		value: snapshot.config.kind === "slidingWindow" ? evaluated.retryAfter !== void 0 ? -1 : evaluated.remaining : evaluated.state.value,
 		ts: evaluated.state.ts,

package/dist/react/index.d.ts

@@ -1060,7 +1060,9 @@ 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>;
+} & DistributiveOmit<UseQueryOptions<FunctionReturnType<Action>, DefaultError>, ReservedQueryOptions>): ConvexActionOptions<Action> & {
+  meta: ConvexQueryMeta;
+};
 /**
  * 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-ssZDPa37.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-BnGZxmnY.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";
@@ -418,6 +418,10 @@ const getTransformer = (transformer) => {
 	transformerCache.set(cacheKey, resolved);
 	return resolved;
 };
+/**
+* Encode request payloads (input direction).
+*/
+const encodeWire = (value, transformer) => getTransformer(transformer).input.serialize(value);
 
 //#endregion
 //#region src/react/http-proxy.ts
@@ -673,7 +677,7 @@ function convexInfiniteQueryOptions(funcRef, args, opts = {}, meta) {
 		cursor: null,
 		limit
 	};
-	const finalEnabled = enabled === false || isSkip ? false : void 0;
+	const finalEnabled = isSkip ? false : enabled;
 	return {
 		queryKey: [
 			"convexQuery",
@@ -686,7 +690,7 @@ function convexInfiniteQueryOptions(funcRef, args, opts = {}, meta) {
 		refetchOnReconnect: false,
 		refetchOnWindowFocus: false,
 		...queryOptions,
-		...finalEnabled === false ? { enabled: false } : {},
+		...finalEnabled === void 0 ? {} : { enabled: finalEnabled },
 		meta: {
 			authType,
 			skipUnauth,
@@ -723,6 +727,19 @@ function useAuthSkip(funcRef, opts) {
 	};
 }
 
+//#endregion
+//#region src/internal/enabled.ts
+/**
+* Combine a computed gate with the caller's `enabled` option.
+* A predicate is preserved (never collapsed to a boolean) so TanStack Query
+* keeps evaluating it; `allowed: false` always wins.
+*/
+function resolveEnabled(allowed, enabled) {
+	if (!allowed) return false;
+	if (typeof enabled === "function") return (query) => enabled(query) !== false;
+	return enabled ?? true;
+}
+
 //#endregion
 //#region src/internal/query-key.ts
 /**
@@ -745,12 +762,19 @@ function isConvexAction$1(queryKey) {
 	return queryKey.length >= 2 && queryKey[0] === "convexAction";
 }
 /**
+* Serialize args the same way they go over the wire, so non-native Convex
+* types the transformer supports (e.g. `Date`) can be hashed.
+*/
+function hashArgs(args) {
+	return JSON.stringify(convexToJson(encodeWire(args)));
+}
+/**
 * 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))}`;
+	return `convexQuery|${funcName}|${hashArgs(args)}`;
 }
 /**
 * Create stable hash for Convex action keys.
@@ -758,7 +782,7 @@ function hashConvexQuery(queryKey) {
 */
 function hashConvexAction(queryKey) {
 	const [, funcName, args] = queryKey;
-	return `convexAction|${funcName}|${JSON.stringify(convexToJson(args))}`;
+	return `convexAction|${funcName}|${hashArgs(args)}`;
 }
 
 //#endregion
@@ -792,12 +816,13 @@ function getStableArgsByHash(hash, args) {
 		stableArgsByHash.set(hash, stableArgs);
 		return stableArgs;
 	}
-	stableArgsByHash.set(hash, args);
+	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);
 	}
-	return args;
+	return stored;
 }
 function useStableQueryArgs(prefix, funcRef, args) {
 	const resolvedArgs = args === skipToken || args == null ? EMPTY_ARGS : args;
@@ -846,14 +871,15 @@ 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(() => {
-		const { skipUnauth: _, subscribe, ...queryOptions } = options ?? {};
+		const { enabled: userEnabled, skipUnauth, subscribe, ...queryOptions } = options ?? {};
 		return {
 			...baseOptions,
 			...queryOptions,
-			enabled: isSkipped ? false : !shouldSkip,
+			enabled: resolveEnabled(!(isSkipped || shouldSkip), userEnabled),
 			meta: {
 				...baseOptions.meta,
 				authType,
+				skipUnauth,
 				subscribe: subscribe !== false
 			}
 		};
@@ -898,7 +924,7 @@ function useConvexInfiniteQueryOptions(funcRef, args, opts) {
 		enabled: isSkipped ? false : enabledOpt,
 		skipUnauth: opts.skipUnauth
 	});
-	const enabled = isSkipped || shouldSkip ? false : enabledOpt;
+	const enabled = resolveEnabled(!(isSkipped || shouldSkip), opts.enabled);
 	const baseOptions = convexInfiniteQueryOptions(funcRef, isSkipped ? {} : args, {
 		...opts,
 		enabled
@@ -933,20 +959,26 @@ function useConvexInfiniteQueryOptions(funcRef, args, opts) {
 function useConvexActionQueryOptions(action, args, options) {
 	const isSkipped = args === skipToken;
 	const enabled = typeof options?.enabled === "function" ? void 0 : options?.enabled;
-	const { shouldSkip } = useAuthSkip(action, {
+	const { authType, shouldSkip } = useAuthSkip(action, {
 		enabled: isSkipped ? false : enabled,
 		skipUnauth: options?.skipUnauth
 	});
 	const stableArgs = useStableQueryArgs("convexAction", action, isSkipped ? EMPTY_ARGS : args);
 	const baseOptions = useMemo(() => convexAction(action, stableArgs.value), [action, stableArgs]);
 	return useMemo(() => {
-		const { skipUnauth: _, ...queryOptions } = options ?? {};
+		const { enabled: userEnabled, skipUnauth, ...queryOptions } = options ?? {};
 		return {
 			...baseOptions,
 			...queryOptions,
-			enabled: isSkipped ? false : !shouldSkip
+			enabled: resolveEnabled(!(isSkipped || shouldSkip), userEnabled),
+			meta: {
+				...baseOptions.meta,
+				authType,
+				skipUnauth
+			}
 		};
 	}, [
+		authType,
 		baseOptions,
 		isSkipped,
 		options,
@@ -2380,7 +2412,7 @@ const useInfiniteQueryInternal = (query, args, options) => {
 			const pageArgs = state.queries[key]?.args;
 			return {
 				...convexQuery(query, pageArgs ? (({ __paginationId, ...rest }) => rest)(pageArgs) : "skip", meta),
-				enabled: !skip && !!state.queries[key],
+				enabled: resolveEnabled(!skip && !!state.queries[key], enabled),
 				structuralSharing: false,
 				...queryOptions ?? {},
 				...index === 0 && prefetchedFirstPage ? { initialData: prefetchedFirstPage } : {},
@@ -2395,6 +2427,7 @@ const useInfiniteQueryInternal = (query, args, options) => {
 			state.pageKeys,
 			state.queries,
 			skip,
+			enabled,
 			meta,
 			queryOptions,
 			prefetchedFirstPage,
@@ -2578,7 +2611,7 @@ function useInfiniteQuery(infiniteOptions) {
 	const result = useInfiniteQueryInternal(query, args, {
 		limit,
 		...queryOptions,
-		enabled: !shouldSkip
+		enabled: resolveEnabled(!shouldSkip, factoryEnabled)
 	});
 	const authLoadingApplies = authType === "optional" || authType === "required";
 	const isClientError = isCRPCClientError(result.error);

package/dist/rsc/index.js

@@ -1,7 +1,7 @@
 import { n as defaultIsUnauthorized } from "../error-Bvo7YEhk.js";
 import { n as getFuncRef, r as getFunctionMeta, t as buildMetaIndex } from "../meta-utils-D9K4fICl.js";
-import { i as decodeWire, s as getTransformer } from "../transformer-C6pGVHqx.js";
-import { n as convexInfiniteQueryOptions, r as convexQuery } from "../query-options-C96zLANM.js";
+import { o as encodeWire, s as getTransformer } from "../transformer-C6pGVHqx.js";
+import { n as convexInfiniteQueryOptions, o as executeHttpRequest, r as convexQuery } from "../query-options-C_eBSIXG.js";
 import { convexToJson } from "convex/values";
 import { getFunctionName } from "convex/server";
 import { fetchAction, fetchQuery } from "convex/nextjs";
@@ -28,37 +28,19 @@ function buildHttpQueryOptions(route, routeKey, args) {
 /**
 * Execute an HTTP route fetch.
 * Called by getServerQueryClientOptions queryFn.
+*
+* Shares the browser client's request builder so a prefetched entry hydrates
+* the client cache instead of being refetched from a different URL.
 */
 async function fetchHttpRoute(convexSiteUrl, routeMeta, args, token, transformer) {
-	const url = buildUrl(convexSiteUrl, routeMeta.path, args);
-	const response = await fetch(url, {
-		method: routeMeta.method,
-		headers: {
-			"Content-Type": "application/json",
-			...token ? { Authorization: `Bearer ${token}` } : {}
-		}
-	});
-	if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
-	if (response.headers.get("content-length") === "0" || response.status === 204) return null;
-	return decodeWire(await response.json(), transformer);
-}
-/**
-* Build URL with path params and query params.
-*/
-function buildUrl(convexSiteUrl, pathTemplate, args) {
-	const remaining = { ...args };
-	const path = pathTemplate.replace(/:(\w+)/g, (_, key) => {
-		const value = remaining[key];
-		delete remaining[key];
-		return value !== null && value !== void 0 ? encodeURIComponent(String(value)) : "";
-	});
-	const queryEntries = Object.entries(remaining).filter(([_, v]) => v !== void 0 && v !== null);
-	if (queryEntries.length > 0) {
-		const params = new URLSearchParams();
-		for (const [key, value] of queryEntries) params.set(key, String(value));
-		return `${convexSiteUrl}${path}?${params.toString()}`;
-	}
-	return convexSiteUrl + path;
+	return await executeHttpRequest({
+		args,
+		baseHeaders: token ? { Authorization: `Bearer ${token}` } : void 0,
+		convexSiteUrl,
+		procedureName: `${routeMeta.method} ${routeMeta.path}`,
+		route: routeMeta,
+		transformer
+	}) ?? null;
 }
 
 //#endregion
@@ -150,12 +132,19 @@ function isConvexAction(queryKey) {
 	return queryKey.length >= 2 && queryKey[0] === "convexAction";
 }
 /**
+* Serialize args the same way they go over the wire, so non-native Convex
+* types the transformer supports (e.g. `Date`) can be hashed.
+*/
+function hashArgs(args) {
+	return JSON.stringify(convexToJson(encodeWire(args)));
+}
+/**
 * 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))}`;
+	return `convexQuery|${funcName}|${hashArgs(args)}`;
 }
 /**
 * Create stable hash for Convex action keys.
@@ -163,7 +152,7 @@ function hashConvexQuery(queryKey) {
 */
 function hashConvexAction(queryKey) {
 	const [, funcName, args] = queryKey;
-	return `convexAction|${funcName}|${JSON.stringify(convexToJson(args))}`;
+	return `convexAction|${funcName}|${hashArgs(args)}`;
 }
 
 //#endregion

package/dist/server/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as ActionProcedureBuilder, A as CRPCError, B as RuntimeEnv, C as createProcedureHandlerFactory, Ct as zCustomQuery, D as WithHttpRouter, Dt as zodToConvex, E as typedProcedureResolver, Et as zodOutputToConvexFields, F as getCRPCErrorFromUnknown, G as createLazyCaller, H as ConvexContext, I as getHTTPStatusCodeFromError, J as ServerCaller, K as CallerMeta, L as isCRPCError, M as CRPCErrorData, N as CRPC_ERROR_CODES_BY_KEY, O as inferApiInputs, Ot as zodToConvexFields, P as CRPC_ERROR_CODE_TO_HTTP, Q as getGeneratedValue, R as toCRPCError, S as createProcedureCallerFactory, St as zCustomMutation, T as getGeneratedFunctionReference, Tt as zodOutputToConvex, U as createCallerFactory, V as createEnv, W as LazyCaller, X as createApiLeaf, Y as createServerCaller, Z as createGeneratedFunctionReference, _ as ProcedureSchedulableCallerFromRegistry, _t as ZodValidatorFromConvex, a as CreateProcedureCallerFactoryOptions, at as initCRPC, b as createGenericCallerFactory, bt as withSystemFields, c as GeneratedRegistryCallerFactory, ct as extractPathParams, d as GeneratedRegistryHandlerForContext, dt as ConvexValidatorFromZod, et as CRPCFunctionTypeHint, f as ProcedureActionCallerFromRegistry, ft as ConvexValidatorFromZodOutput, g as ProcedureFromFunctionReference, gt as ZodFromValidatorBase, h as ProcedureDefinition, ht as Zid, i as registerProcedureNameLookup, it as createMiddlewareFactory, j as CRPCErrorCode, k as inferApiOutputs, l as GeneratedRegistryCallerForContext, lt as handleHttpError, m as ProcedureCallerFromRegistry, mt as ZCustomCtx, n as ProcedureNameLookup, nt as ProcedureBuilder, o as GeneratedProcedureRegistry, ot as HttpProcedureBuilder, p as ProcedureCaller, pt as CustomBuilder, q as CallerOpts, r as inferProcedureNameFromCallsite, rt as QueryProcedureBuilder, s as GeneratedProcedureRegistryEntry, st as createHttpProcedureBuilder, t as ProcedureNameEntry, tt as MutationProcedureBuilder, u as GeneratedRegistryHandlerFactory, ut as matchPathParams, v as ProcedureScheduleCallerFromRegistry, vt as convexToZod, w as defineProcedure, wt as zid, x as createGenericHandlerFactory, xt as zCustomAction, y as createGeneratedRegistryRuntime, yt as convexToZodFields, z as CreateEnvOptions } from "../procedure-name-Cy1AxayA.js";
+import { $ as ActionProcedureBuilder, A as CRPCError, B as RuntimeEnv, C as createProcedureHandlerFactory, Ct as zCustomQuery, D as WithHttpRouter, Dt as zodToConvex, E as typedProcedureResolver, Et as zodOutputToConvexFields, F as getCRPCErrorFromUnknown, G as createLazyCaller, H as ConvexContext, I as getHTTPStatusCodeFromError, J as ServerCaller, K as CallerMeta, L as isCRPCError, M as CRPCErrorData, N as CRPC_ERROR_CODES_BY_KEY, O as inferApiInputs, Ot as zodToConvexFields, P as CRPC_ERROR_CODE_TO_HTTP, Q as getGeneratedValue, R as toCRPCError, S as createProcedureCallerFactory, St as zCustomMutation, T as getGeneratedFunctionReference, Tt as zodOutputToConvex, U as createCallerFactory, V as createEnv, W as LazyCaller, X as createApiLeaf, Y as createServerCaller, Z as createGeneratedFunctionReference, _ as ProcedureSchedulableCallerFromRegistry, _t as ZodValidatorFromConvex, a as CreateProcedureCallerFactoryOptions, at as initCRPC, b as createGenericCallerFactory, bt as withSystemFields, c as GeneratedRegistryCallerFactory, ct as extractPathParams, d as GeneratedRegistryHandlerForContext, dt as ConvexValidatorFromZod, et as CRPCFunctionTypeHint, f as ProcedureActionCallerFromRegistry, ft as ConvexValidatorFromZodOutput, g as ProcedureFromFunctionReference, gt as ZodFromValidatorBase, h as ProcedureDefinition, ht as Zid, i as registerProcedureNameLookup, it as createMiddlewareFactory, j as CRPCErrorCode, k as inferApiOutputs, l as GeneratedRegistryCallerForContext, lt as handleHttpError, m as ProcedureCallerFromRegistry, mt as ZCustomCtx, n as ProcedureNameLookup, nt as ProcedureBuilder, o as GeneratedProcedureRegistry, ot as HttpProcedureBuilder, p as ProcedureCaller, pt as CustomBuilder, q as CallerOpts, r as inferProcedureNameFromCallsite, rt as QueryProcedureBuilder, s as GeneratedProcedureRegistryEntry, st as createHttpProcedureBuilder, t as ProcedureNameEntry, tt as MutationProcedureBuilder, u as GeneratedRegistryHandlerFactory, ut as matchPathParams, v as ProcedureScheduleCallerFromRegistry, vt as convexToZod, w as defineProcedure, wt as zid, x as createGenericHandlerFactory, xt as zCustomAction, y as createGeneratedRegistryRuntime, yt as convexToZodFields, z as CreateEnvOptions } from "../procedure-name-Bo5KMcqc.js";
 import { C as HttpProcedure, D as ProcedureMeta, E as InferHttpInput, S as HttpMethod, T as HttpRouteDefinition, _ as extractRouteMap, b as HttpActionHandler, d as CRPCHttpRouter, f as HttpRouterDef, g as createHttpRouterFactory, h as createHttpRouter, m as HttpRouterWithHono, p as HttpRouterRecord, v as CRPCHonoHandler, w as HttpProcedureBuilderDef, x as HttpHandlerOpts, y as HttpActionConstructor } from "../http-types-zsMHb_QN.js";
 import { a as MergeZodObjects, c as MiddlewareMarker, d as MiddlewareProcedureType, f as MiddlewareResult, g as UnsetMarker, h as Simplify, i as IntersectIfDefined, l as MiddlewareNext, m as ResolveIfSet, n as AnyMiddlewareBuilder, o as MiddlewareBuilder, p as Overwrite, r as GetRawInputFn, s as MiddlewareFunction, t as AnyMiddleware, u as MiddlewareProcedureInfo } from "../types-CnTpHR1F.js";
 import { a as isMutationCtx, c as isSchedulerCtx, d as requireQueryCtx, f as requireRunMutationCtx, i as isActionCtx, l as requireActionCtx, n as RunMutationCtx, o as isQueryCtx, p as requireSchedulerCtx, r as SchedulerCtx, s as isRunMutationCtx, t as GenericCtx, u as requireMutationCtx } from "../context-utils-BBUtBqjN.js";

package/dist/server/index.js

@@ -1,6 +1,6 @@
 import { a as isMutationCtx, c as isSchedulerCtx, d as requireQueryCtx, f as requireRunMutationCtx, i as isActionCtx, l as requireActionCtx, n as createGeneratedFunctionReference, o as isQueryCtx, p as requireSchedulerCtx, r as getGeneratedValue, s as isRunMutationCtx, t as createApiLeaf, u as requireMutationCtx } from "../api-entry-N3nBOlI2.js";
-import { n as createLazyCaller, r as createServerCaller, t as createCallerFactory } from "../caller-factory-NEfgD5E0.js";
-import { A as zid, C as toCRPCError, D as zCustomAction, E as withSystemFields, M as zodOutputToConvexFields, N as zodToConvex, O as zCustomMutation, P as zodToConvexFields, S as isCRPCError, T as convexToZodFields, _ as CRPCError, a as createMiddlewareFactory, b as getCRPCErrorFromUnknown, c as registerProcedureNameLookup, d as createHttpRouterFactory, f as extractRouteMap, g as matchPathParams, h as handleHttpError, i as QueryProcedureBuilder, j as zodOutputToConvex, k as zCustomQuery, l as HttpRouterWithHono, m as extractPathParams, n as MutationProcedureBuilder, o as initCRPC, p as createHttpProcedureBuilder, r as ProcedureBuilder, s as inferProcedureNameFromCallsite, t as ActionProcedureBuilder, u as createHttpRouter, v as CRPC_ERROR_CODES_BY_KEY, w as convexToZod, x as getHTTPStatusCodeFromError, y as CRPC_ERROR_CODE_TO_HTTP } from "../builder-DBgto1yn.js";
-import { a as createProcedureHandlerFactory, c as typedProcedureResolver, i as createProcedureCallerFactory, l as createEnv, n as createGenericCallerFactory, o as defineProcedure, r as createGenericHandlerFactory, s as getGeneratedFunctionReference, t as createGeneratedRegistryRuntime } from "../procedure-caller-9m6NBxQu.js";
+import { n as createLazyCaller, r as createServerCaller, t as createCallerFactory } from "../caller-factory-DHywSoGZ.js";
+import { A as zid, C as toCRPCError, D as zCustomAction, E as withSystemFields, M as zodOutputToConvexFields, N as zodToConvex, O as zCustomMutation, P as zodToConvexFields, S as isCRPCError, T as convexToZodFields, _ as CRPCError, a as createMiddlewareFactory, b as getCRPCErrorFromUnknown, c as registerProcedureNameLookup, d as createHttpRouterFactory, f as extractRouteMap, g as matchPathParams, h as handleHttpError, i as QueryProcedureBuilder, j as zodOutputToConvex, k as zCustomQuery, l as HttpRouterWithHono, m as extractPathParams, n as MutationProcedureBuilder, o as initCRPC, p as createHttpProcedureBuilder, r as ProcedureBuilder, s as inferProcedureNameFromCallsite, t as ActionProcedureBuilder, u as createHttpRouter, v as CRPC_ERROR_CODES_BY_KEY, w as convexToZod, x as getHTTPStatusCodeFromError, y as CRPC_ERROR_CODE_TO_HTTP } from "../builder-f4F_NRvK.js";
+import { a as createProcedureHandlerFactory, c as typedProcedureResolver, i as createProcedureCallerFactory, l as createEnv, n as createGenericCallerFactory, o as defineProcedure, r as createGenericHandlerFactory, s as getGeneratedFunctionReference, t as createGeneratedRegistryRuntime } from "../procedure-caller-Rj6z3ai7.js";
 
 export { ActionProcedureBuilder, CRPCError, CRPC_ERROR_CODES_BY_KEY, CRPC_ERROR_CODE_TO_HTTP, HttpRouterWithHono, MutationProcedureBuilder, ProcedureBuilder, QueryProcedureBuilder, convexToZod, convexToZodFields, createApiLeaf, createCallerFactory, createEnv, createGeneratedFunctionReference, createGeneratedRegistryRuntime, createGenericCallerFactory, createGenericHandlerFactory, createHttpProcedureBuilder, createHttpRouter, createHttpRouterFactory, createLazyCaller, createMiddlewareFactory, createProcedureCallerFactory, createProcedureHandlerFactory, createServerCaller, defineProcedure, extractPathParams, extractRouteMap, getCRPCErrorFromUnknown, getGeneratedFunctionReference, getGeneratedValue, getHTTPStatusCodeFromError, handleHttpError, inferProcedureNameFromCallsite, initCRPC, isActionCtx, isCRPCError, isMutationCtx, isQueryCtx, isRunMutationCtx, isSchedulerCtx, matchPathParams, registerProcedureNameLookup, requireActionCtx, requireMutationCtx, requireQueryCtx, requireRunMutationCtx, requireSchedulerCtx, toCRPCError, typedProcedureResolver, withSystemFields, zCustomAction, zCustomMutation, zCustomQuery, zid, zodOutputToConvex, zodOutputToConvexFields, zodToConvex, zodToConvexFields };

package/dist/solid/index.js

@@ -57,7 +57,10 @@ const useConvexAuthBridge = () => useContext(ConvexAuthBridgeContext);
 /** Decode JWT expiration (ms timestamp) from token */
 function decodeJwtExp(token) {
 	try {
-		const payload = JSON.parse(atob(token.split(".")[1]));
+		const segment = token.split(".")[1];
+		if (!segment) return null;
+		const binary = atob(segment.replaceAll("-", "+").replaceAll("_", "/"));
+		const payload = JSON.parse(new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0))));
 		return payload.exp ? payload.exp * 1e3 : null;
 	} catch {
 		return null;
@@ -699,6 +702,10 @@ const getTransformer = (transformer) => {
 	transformerCache.set(cacheKey, resolved);
 	return resolved;
 };
+/**
+* Encode request payloads (input direction).
+*/
+const encodeWire = (value, transformer) => getTransformer(transformer).input.serialize(value);
 
 //#endregion
 //#region src/solid/http-proxy.ts
@@ -954,7 +961,7 @@ function convexInfiniteQueryOptions(funcRef, args, opts = {}, meta) {
 		cursor: null,
 		limit
 	};
-	const finalEnabled = enabled === false || isSkip ? false : void 0;
+	const finalEnabled = isSkip ? false : enabled;
 	return {
 		queryKey: [
 			"convexQuery",
@@ -967,7 +974,7 @@ function convexInfiniteQueryOptions(funcRef, args, opts = {}, meta) {
 		refetchOnReconnect: false,
 		refetchOnWindowFocus: false,
 		...queryOptions,
-		...finalEnabled === false ? { enabled: false } : {},
+		...finalEnabled === void 0 ? {} : { enabled: finalEnabled },
 		meta: {
 			authType,
 			skipUnauth,
@@ -1785,12 +1792,19 @@ function isConvexAction$1(queryKey) {
 	return queryKey.length >= 2 && queryKey[0] === "convexAction";
 }
 /**
+* Serialize args the same way they go over the wire, so non-native Convex
+* types the transformer supports (e.g. `Date`) can be hashed.
+*/
+function hashArgs(args) {
+	return JSON.stringify(convexToJson(encodeWire(args)));
+}
+/**
 * 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))}`;
+	return `convexQuery|${funcName}|${hashArgs(args)}`;
 }
 /**
 * Create stable hash for Convex action keys.
@@ -1798,7 +1812,7 @@ function hashConvexQuery(queryKey) {
 */
 function hashConvexAction(queryKey) {
 	const [, funcName, args] = queryKey;
-	return `convexAction|${funcName}|${JSON.stringify(convexToJson(args))}`;
+	return `convexAction|${funcName}|${hashArgs(args)}`;
 }
 
 //#endregion