@raf-query/react 0.10.0 → 0.10.2

package/CHANGELOG.md

@@ -1,20 +1,37 @@
 # Changelog
 
+## [0.10.2](https://github.com/KATT/raf-query/compare/0.10.1...0.10.2) (2026-10-16)
+
+### Features
+
+* **react:** re-render useQuery readers of the thenable's status when the first load settles (2/3) ([#198](https://github.com/KATT/raf-query/issues/198)) ([436d83c](https://github.com/KATT/raf-query/commit/436d83cfd6a3944265eb56d5597c322342c5a6c6))
+* **react:** type useQuery's promise as a Thenable (1/3) ([#200](https://github.com/KATT/raf-query/issues/200)) ([47e5309](https://github.com/KATT/raf-query/commit/47e530957565a2bd345642ae7a4be5d3c501ffb2))
+
+## [0.10.1](https://github.com/KATT/raf-query/compare/0.10.0...0.10.1) (2026-10-16)
+
+### Features
+
+- **core:** export QueryClient, dehydrate, hydrate, allKeyed and the useQuery controls from @raf-query/core ([#193](https://github.com/KATT/raf-query/issues/193)) ([54492ab](https://github.com/KATT/raf-query/commit/54492abbe2966a0645e8a4c77f9c5ab31d6e3a20)), references [#194](https://github.com/KATT/raf-query/issues/194)
+
+### Documentation
+
+- React Router client-only and server sections with one server client per request, Effect under Integrations, official docs links, and ensure waits like fetch in server-only code ([#192](https://github.com/KATT/raf-query/issues/192)) ([841ffcf](https://github.com/KATT/raf-query/commit/841ffcf4d0fa0a40dfc58dc65bfcfadca8948874)), references [#190](https://github.com/KATT/raf-query/issues/190)
+
 ## [0.10.0](https://github.com/KATT/raf-query/compare/0.9.2...0.10.0) (2026-10-16)
 
 ### ⚠ BREAKING CHANGES
 
-* **react:** import HydrationBoundary from @raf-query/react in RSC and React Router ([#175](https://github.com/KATT/raf-query/issues/175))
-* **react:** import QueryProvider from @raf-query/react ([#177](https://github.com/KATT/raf-query/issues/177))
+- **react:** import HydrationBoundary from @raf-query/react in RSC and React Router ([#175](https://github.com/KATT/raf-query/issues/175))
+- **react:** import QueryProvider from @raf-query/react ([#177](https://github.com/KATT/raf-query/issues/177))
 
 ### Features
 
-* **react:** import HydrationBoundary from @raf-query/react in RSC and React Router ([#175](https://github.com/KATT/raf-query/issues/175)) ([244705c](https://github.com/KATT/raf-query/commit/244705c74841d280a596195dec5cf5e5d5617fe5))
-* **react:** import QueryProvider from @raf-query/react ([#177](https://github.com/KATT/raf-query/issues/177)) ([fb4fceb](https://github.com/KATT/raf-query/commit/fb4fcebb404906b4a9d5716a1d45cb33c82da2fb)), references [#175](https://github.com/KATT/raf-query/issues/175) [#175](https://github.com/KATT/raf-query/issues/175) [#175](https://github.com/KATT/raf-query/issues/175) [#175](https://github.com/KATT/raf-query/issues/175)
+- **react:** import HydrationBoundary from @raf-query/react in RSC and React Router ([#175](https://github.com/KATT/raf-query/issues/175)) ([244705c](https://github.com/KATT/raf-query/commit/244705c74841d280a596195dec5cf5e5d5617fe5))
+- **react:** import QueryProvider from @raf-query/react ([#177](https://github.com/KATT/raf-query/issues/177)) ([fb4fceb](https://github.com/KATT/raf-query/commit/fb4fcebb404906b4a9d5716a1d45cb33c82da2fb)), references [#175](https://github.com/KATT/raf-query/issues/175) [#175](https://github.com/KATT/raf-query/issues/175) [#175](https://github.com/KATT/raf-query/issues/175) [#175](https://github.com/KATT/raf-query/issues/175)
 
 ### Code Refactoring
 
-* **react:** group the HydrationBoundary and QueryProvider files in folders ([#186](https://github.com/KATT/raf-query/issues/186)) ([ad07bb4](https://github.com/KATT/raf-query/commit/ad07bb45ca77fc797cd6b8432685e58f43907258)), references [#175](https://github.com/KATT/raf-query/issues/175)
+- **react:** group the HydrationBoundary and QueryProvider files in folders ([#186](https://github.com/KATT/raf-query/issues/186)) ([ad07bb4](https://github.com/KATT/raf-query/commit/ad07bb45ca77fc797cd6b8432685e58f43907258)), references [#175](https://github.com/KATT/raf-query/issues/175)
 
 ## [0.9.2](https://github.com/KATT/raf-query/compare/0.9.1...0.9.2) (2026-10-15)
 

package/README.md

@@ -124,11 +124,11 @@ function PostPage() {
 
 ## Entry points
 
-| Import                             | Use                                                                                                                                      |
-| ---------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| `@raf-query/react`                 | `QueryClient`, `QueryClientProvider`, `QueryProvider`, `useQuery`, `useWaterfall`, `useIsFetching`, `HydrationBoundary`, and all of core |
-| `@raf-query/react/tanstack-router` | [TanStack Start and Router](https://raf-query.katt.dev/docs/tanstack-start) SSR streaming                                                |
-| `@raf-query/react/devtools`        | The [devtools](https://raf-query.katt.dev/docs/devtools) panel; omit the element to tree-shake it                                        |
+| Import                             | Use                                                                                                                                               |
+| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@raf-query/react`                 | `QueryClientProvider`, `QueryProvider`, `useQuery`, `useWaterfall`, `useIsFetching`, `HydrationBoundary`, and all of core, `QueryClient` included |
+| `@raf-query/react/tanstack-router` | [TanStack Start and Router](https://raf-query.katt.dev/docs/tanstack-start) SSR streaming                                                         |
+| `@raf-query/react/devtools`        | The [devtools](https://raf-query.katt.dev/docs/devtools) panel; omit the element to tree-shake it                                                 |
 
 ## License
 

package/dist/devtools-panel.d.mts

@@ -1,4 +1,4 @@
-import { QueryClient } from "./client.mjs";
+import { QueryClient } from "@raf-query/core";
 import { CSSProperties } from "react";
 //#region src/devtools-panel.d.ts
 export type DevtoolsTheme = "dark" | "light" | "system";

package/dist/devtools-panel.mjs

@@ -2,9 +2,9 @@
 import { useOptionalQueryClient } from "./provider.mjs";
 import { countByStatus, sortOrders, statuses, useQueryRows, visibleRows } from "./devtools-store.mjs";
 import { Query } from "@raf-query/core";
-import { Effect, Predicate } from "effect";
 import { useState, useSyncExternalStore } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Effect, Predicate } from "effect";
 //#region src/devtools-panel.tsx
 const palettes = {
 	dark: {

package/dist/hydration-boundary/hydrate.mjs

@@ -1,7 +1,6 @@
 "use client";
-import { hydrate } from "../client.mjs";
 import { useQueryClient } from "../provider.mjs";
-import { Query, hashKey } from "@raf-query/core";
+import { Query, hashKey, hydrate } from "@raf-query/core";
 import { useEffect, useState } from "react";
 //#region src/hydration-boundary/hydrate.tsx
 /**

package/dist/hydration-boundary/hydration-boundary-react-server.mjs

@@ -1,6 +1,6 @@
-import { dehydrate } from "../client.mjs";
 import { Hydrate } from "./hydrate.mjs";
 import { sentHashes } from "./sent.mjs";
+import { dehydrate } from "@raf-query/core";
 import { jsx } from "react/jsx-runtime";
 //#region src/hydration-boundary/hydration-boundary-react-server.tsx
 /**

package/dist/hydration-boundary/hydration-boundary.d.mts

@@ -1,5 +1,4 @@
-import { QueryClient } from "../client.mjs";
-import { DehydrateOptions, DehydratedState, HydrateOptions } from "@raf-query/core";
+import { DehydrateOptions, DehydratedState, HydrateOptions, QueryClient } from "@raf-query/core";
 import { ReactNode } from "react";
 //#region src/hydration-boundary/hydration-boundary.d.ts
 export type HydrationBoundaryProps = {

package/dist/index-react-server.d.mts

@@ -1,11 +1,9 @@
-import { QueryClient, QueryClientConfig, dehydrate, hydrate } from "./client.mjs";
-import { Settled, allKeyed } from "./all-keyed.mjs";
 import { QueryClientProvider, useQueryClient } from "./provider.mjs";
 import { QueryProvider } from "./query-provider/query-provider.mjs";
 import { useIsFetching } from "./use-is-fetching.mjs";
-import { HasTypedError, PagingControls, QueryControls, ThrowsOnError, UseQueryControls, UseQueryOptions, UseQueryResult, UseQueryResultWithData, UseQueryThrowOptions, useQuery } from "./use-query.mjs";
+import { UseQueryResult, UseQueryResultWithData, useQuery } from "./use-query.mjs";
 import { useWaterfall } from "./use-waterfall.mjs";
 import "./index-shared.mjs";
 import { HydrationBoundary } from "./hydration-boundary/hydration-boundary-react-server.mjs";
 export * from "@raf-query/core";
-export { type HasTypedError, HydrationBoundary, type PagingControls, QueryClient, type QueryClientConfig, QueryClientProvider, type QueryControls, QueryProvider, type Settled, type ThrowsOnError, type UseQueryControls, type UseQueryOptions, type UseQueryResult, type UseQueryResultWithData, type UseQueryThrowOptions, allKeyed, dehydrate, hydrate, useIsFetching, useQuery, useQueryClient, useWaterfall };
+export { HydrationBoundary, QueryClientProvider, QueryProvider, type UseQueryResult, type UseQueryResultWithData, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index-react-server.mjs

@@ -1,5 +1,3 @@
-import { allKeyed } from "./all-keyed.mjs";
-import { QueryClient, dehydrate, hydrate } from "./client.mjs";
 import { QueryClientProvider, useQueryClient } from "./provider.mjs";
 import { QueryProvider } from "./query-provider/query-provider.mjs";
 import { useIsFetching } from "./use-is-fetching.mjs";
@@ -7,4 +5,4 @@ import { useQuery } from "./use-query.mjs";
 import { useWaterfall } from "./use-waterfall.mjs";
 import { HydrationBoundary } from "./hydration-boundary/hydration-boundary-react-server.mjs";
 export * from "@raf-query/core";
-export { HydrationBoundary, QueryClient, QueryClientProvider, QueryProvider, allKeyed, dehydrate, hydrate, useIsFetching, useQuery, useQueryClient, useWaterfall };
+export { HydrationBoundary, QueryClientProvider, QueryProvider, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index-shared.d.mts

@@ -1,9 +1,7 @@
-import { QueryClient, QueryClientConfig, dehydrate, hydrate } from "./client.mjs";
-import { Settled, allKeyed } from "./all-keyed.mjs";
 import { QueryClientProvider, useQueryClient } from "./provider.mjs";
 import { QueryProvider } from "./query-provider/query-provider.mjs";
 import { useIsFetching } from "./use-is-fetching.mjs";
-import { HasTypedError, PagingControls, QueryControls, ThrowsOnError, UseQueryControls, UseQueryOptions, UseQueryResult, UseQueryResultWithData, UseQueryThrowOptions, useQuery } from "./use-query.mjs";
+import { UseQueryResult, UseQueryResultWithData, useQuery } from "./use-query.mjs";
 import { useWaterfall } from "./use-waterfall.mjs";
 export * from "@raf-query/core";
-export { type HasTypedError, type PagingControls, QueryClient, type QueryClientConfig, QueryClientProvider, type QueryControls, QueryProvider, type Settled, type ThrowsOnError, type UseQueryControls, type UseQueryOptions, type UseQueryResult, type UseQueryResultWithData, type UseQueryThrowOptions, allKeyed, dehydrate, hydrate, useIsFetching, useQuery, useQueryClient, useWaterfall };
+export { QueryClientProvider, QueryProvider, type UseQueryResult, type UseQueryResultWithData, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index-shared.mjs

@@ -1,9 +1,7 @@
-import { allKeyed } from "./all-keyed.mjs";
-import { QueryClient, dehydrate, hydrate } from "./client.mjs";
 import { QueryClientProvider, useQueryClient } from "./provider.mjs";
 import { QueryProvider } from "./query-provider/query-provider.mjs";
 import { useIsFetching } from "./use-is-fetching.mjs";
 import { useQuery } from "./use-query.mjs";
 import { useWaterfall } from "./use-waterfall.mjs";
 export * from "@raf-query/core";
-export { QueryClient, QueryClientProvider, QueryProvider, allKeyed, dehydrate, hydrate, useIsFetching, useQuery, useQueryClient, useWaterfall };
+export { QueryClientProvider, QueryProvider, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index.d.mts

@@ -1,11 +1,9 @@
-import { QueryClient, QueryClientConfig, dehydrate, hydrate } from "./client.mjs";
-import { Settled, allKeyed } from "./all-keyed.mjs";
 import { QueryClientProvider, useQueryClient } from "./provider.mjs";
 import { QueryProvider } from "./query-provider/query-provider.mjs";
 import { useIsFetching } from "./use-is-fetching.mjs";
-import { HasTypedError, PagingControls, QueryControls, ThrowsOnError, UseQueryControls, UseQueryOptions, UseQueryResult, UseQueryResultWithData, UseQueryThrowOptions, useQuery } from "./use-query.mjs";
+import { UseQueryResult, UseQueryResultWithData, useQuery } from "./use-query.mjs";
 import { useWaterfall } from "./use-waterfall.mjs";
 import "./index-shared.mjs";
 import { HydrationBoundary } from "./hydration-boundary/hydration-boundary.mjs";
 export * from "@raf-query/core";
-export { type HasTypedError, HydrationBoundary, type PagingControls, QueryClient, type QueryClientConfig, QueryClientProvider, type QueryControls, QueryProvider, type Settled, type ThrowsOnError, type UseQueryControls, type UseQueryOptions, type UseQueryResult, type UseQueryResultWithData, type UseQueryThrowOptions, allKeyed, dehydrate, hydrate, useIsFetching, useQuery, useQueryClient, useWaterfall };
+export { HydrationBoundary, QueryClientProvider, QueryProvider, type UseQueryResult, type UseQueryResultWithData, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index.mjs

@@ -1,5 +1,3 @@
-import { allKeyed } from "./all-keyed.mjs";
-import { QueryClient, dehydrate, hydrate } from "./client.mjs";
 import { QueryClientProvider, useQueryClient } from "./provider.mjs";
 import { QueryProvider } from "./query-provider/query-provider.mjs";
 import { useIsFetching } from "./use-is-fetching.mjs";
@@ -7,4 +5,4 @@ import { useQuery } from "./use-query.mjs";
 import { useWaterfall } from "./use-waterfall.mjs";
 import { HydrationBoundary } from "./hydration-boundary/hydration-boundary.mjs";
 export * from "@raf-query/core";
-export { HydrationBoundary, QueryClient, QueryClientProvider, QueryProvider, allKeyed, dehydrate, hydrate, useIsFetching, useQuery, useQueryClient, useWaterfall };
+export { HydrationBoundary, QueryClientProvider, QueryProvider, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/provider.d.mts

@@ -1,4 +1,4 @@
-import { QueryClient } from "./client.mjs";
+import { QueryClient } from "@raf-query/core";
 import { ReactNode } from "react";
 //#region src/provider.d.ts
 /**

package/dist/query-provider/query-provider.d.mts

@@ -1,4 +1,4 @@
-import { QueryClientConfig } from "../client.mjs";
+import { QueryClientConfig } from "@raf-query/core";
 import { ReactNode } from "react";
 //#region src/query-provider/query-provider.d.ts
 /**

package/dist/query-provider/query-provider.mjs

@@ -1,7 +1,7 @@
 "use client";
-import { QueryClient } from "../client.mjs";
 import { QueryClientProvider } from "../provider.mjs";
 import { requestInBrowserOnly } from "./browser-requests.mjs";
+import { QueryClient } from "@raf-query/core";
 import { useState } from "react";
 import { jsx } from "react/jsx-runtime";
 //#region src/query-provider/query-provider.tsx

package/dist/tanstack-router-shared.d.mts

@@ -1,5 +1,4 @@
-import { QueryClient } from "./client.mjs";
-import { DehydrateOptions, DehydratedState, HydrateOptions, QueryHandle } from "@raf-query/core";
+import { DehydrateOptions, DehydratedState, HydrateOptions, QueryClient, QueryHandle } from "@raf-query/core";
 import { AnyRouter } from "@tanstack/react-router";
 //#region src/tanstack-router-shared.d.ts
 declare module "@tanstack/react-router" {

package/dist/tanstack-router-shared.mjs

@@ -1,4 +1,4 @@
-import { hydrate } from "./client.mjs";
+import { hydrate } from "@raf-query/core";
 import { Predicate } from "effect";
 import { isRedirect } from "@tanstack/react-router";
 //#region src/tanstack-router-shared.ts

package/dist/use-query.d.mts

@@ -1,68 +1,7 @@
-import { DataOf, ErrorOf, InputOf, IsPaged, QueryFactory, QueryHandle, QueryHandleWithData, QueryKey, QueryObserver } from "@raf-query/core";
+import { DataOf, ErrorOf, QueryFactory, QueryHandle, QueryHandleWithData, Thenable, ThrowsOnError, UseQueryControls, UseQueryOptions, UseQueryThrowOptions } from "@raf-query/core";
 import { Result } from "effect";
 //#region src/use-query.d.ts
-/** `refetchInterval`, `refetchOnWindowFocus`, `refetchOnReconnect`, `whilePending`. */
-export type UseQueryOptions = QueryObserver.Options;
-/**
- * `throwOnError` only when {@link ErrorOf} is typed (Effect `queryFn`).
- * Promise factories always throw; the option is not part of their options.
- */
-export type UseQueryThrowOptions<TFactory extends QueryFactory> = HasTypedError<TFactory> extends true ? {
-  /**
-   * When `false`, the first tuple slot is a `Result` instead of a
-   * rejecting promise. Omit to use the client's default (`false`
-   * with a `layer`, `true` without).
-   */
-  readonly throwOnError?: boolean;
-} : {
-  readonly throwOnError?: never;
-};
-/** The second element of {@link useQuery}'s result. */
-export interface QueryControls<TFactory extends QueryFactory> {
-  /** Error of the last failed request. Existing data stays readable. */
-  readonly error: unknown;
-  /** Stable string form of the handle's key, for `key` props. */
-  readonly hash: string;
-  /** Input of the data in the promise; differs from the handle's while `isPrevious`. */
-  readonly input: InputOf<TFactory>;
-  /** A request is in flight: first load, new input, or background refetch. */
-  readonly isFetching: boolean;
-  /** No data yet for the handle's input. */
-  readonly isPending: boolean;
-  /** The promise holds a previous input's data (`whilePending: "previous"`). */
-  readonly isPrevious: boolean;
-  /** The data is older than `staleTime`, or was invalidated. */
-  readonly isStale: boolean;
-  /** Key of the data in the promise; differs from the handle's while `isPrevious`. */
-  readonly key: QueryKey;
-  /** Refetch now. Resolves when the request settles; never rejects. */
-  refetch(): Promise<void>;
-  /** When the data in the promise was fetched (ms since epoch); `0` before that. */
-  readonly updatedAt: number;
-}
-/** Extra controls for factories that return `infiniteQueryOptions(...)`. */
-export interface PagingControls {
-  fetchNextPage(): Promise<void>;
-  fetchPreviousPage(): Promise<void>;
-  readonly hasNextPage: boolean;
-  readonly hasPreviousPage: boolean;
-  readonly isFetchingNextPage: boolean;
-  readonly isFetchingPreviousPage: boolean;
-}
-export type UseQueryControls<TFactory extends QueryFactory> = IsPaged<TFactory> extends true ? QueryControls<TFactory> & PagingControls : QueryControls<TFactory>;
-/**
- * `true` when the factory's error channel is typed (Effect `queryFn`), not
- * `unknown` (promise / plain value).
- */
-export type HasTypedError<TFactory extends QueryFactory> = unknown extends ErrorOf<TFactory> ? false : true;
-/**
- * Whether this read throws on failure. Untyped errors always throw. Typed
- * errors follow `options.throwOnError`, else the client's default (`false`
- * with a `layer`, `true` without). Types treat an omitted flag as `false`
- * (Result), matching a client with a `layer`.
- */
-export type ThrowsOnError<TFactory extends QueryFactory, TThrow extends boolean | undefined> = HasTypedError<TFactory> extends false ? true : TThrow extends boolean ? TThrow : false;
-export type UseQueryResult<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = ThrowsOnError<TFactory, TThrow> extends true ? readonly [promise: Promise<DataOf<TFactory>>, controls: UseQueryControls<TFactory>] : readonly [promise: Promise<Result.Result<DataOf<TFactory>, ErrorOf<TFactory>>>, controls: UseQueryControls<TFactory>];
+export type UseQueryResult<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = ThrowsOnError<TFactory, TThrow> extends true ? readonly [promise: Thenable<DataOf<TFactory>>, controls: UseQueryControls<TFactory>] : readonly [promise: Thenable<Result.Result<DataOf<TFactory>, ErrorOf<TFactory>>>, controls: UseQueryControls<TFactory>];
 /** {@link useQuery}'s result for a handle from `ensure` or `fetch`. */
 export type UseQueryResultWithData<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = ThrowsOnError<TFactory, TThrow> extends true ? readonly [data: DataOf<TFactory>, controls: UseQueryControls<TFactory>] : readonly [result: Result.Result<DataOf<TFactory>, ErrorOf<TFactory>>, controls: UseQueryControls<TFactory>];
 /**
@@ -87,7 +26,15 @@ export type UseQueryResultWithData<TFactory extends QueryFactory, TThrow extends
  * The promise is stable per data version and already fulfilled once the
  * cache has data, so `use()` only suspends while there is nothing to show.
  * The component re-renders when the promise changes, and when a control it
- * has read changes; changes to controls it never reads are skipped.
+ * has read changes; changes to controls it never reads are skipped. A
+ * first load settles its pending promise in place: that counts as a change
+ * once the component has read the promise's `status`, `value` or `reason`,
+ * so reading them without `use()` re-renders when the data lands:
+ *
+ * ```tsx
+ * const [tagPromise] = useQuery(tagQuery, loaderData.tag);
+ * const tag = tagPromise.status === "fulfilled" ? tagPromise.value : "…";
+ * ```
  *
  * A handle from `ensure` or `fetch` already has its data, so the hook
  * unwraps the promise itself and returns the data (or `Result`):

package/dist/use-query.mjs

@@ -1,31 +1,13 @@
 "use client";
 import { useQueryClient } from "./provider.mjs";
 import { assertSent } from "./query-provider/browser-requests.mjs";
-import { Query, QueryObserver, fulfilled, pending } from "@raf-query/core";
-import { Effect, Result } from "effect";
+import { Query, QueryObserver, promiseControls, resultThenable } from "@raf-query/core";
 import { use, useEffect, useState, useSyncExternalStore } from "react";
 //#region src/use-query.ts
 function queryFor(client, factory, input) {
 	const args = [input];
 	return client.getQuery(factory, ...args);
 }
-const commands = /* @__PURE__ */ new WeakMap();
-/** One stable Promise function per command Effect, so identities track the query's. */
-function commandFor(effect) {
-	let command = commands.get(effect);
-	if (!command) {
-		command = () => Effect.runPromise(effect);
-		commands.set(effect, command);
-	}
-	return command;
-}
-/** `tracked`, with the observer's command Effects as Promise functions. */
-function withPromiseCommands(tracked) {
-	return new Proxy(tracked, { get: (target, name, receiver) => {
-		if (name === "fetchNextPage" || name === "fetchPreviousPage" || name === "refetch") return commandFor(target[name]);
-		return Reflect.get(target, name, receiver);
-	} });
-}
 function storeFor(query, options) {
 	const observer = QueryObserver.makeUnsafe(query, options);
 	return {
@@ -34,29 +16,6 @@ function storeFor(query, options) {
 		subscribe: (onChange) => QueryObserver.subscribeUnsafe(observer, onChange)
 	};
 }
-/**
-* One `Result` thenable per data thenable, so `use()` sees a stable identity
-* across re-renders the same way it does for the data promise.
-*/
-const resultThenables = /* @__PURE__ */ new WeakMap();
-function asResultThenable(promise) {
-	const cached = resultThenables.get(promise);
-	if (cached) return cached;
-	let next;
-	if (promise.status === "fulfilled") next = fulfilled(Result.succeed(promise.value));
-	else if (promise.status === "rejected") next = fulfilled(Result.fail(promise.reason));
-	else {
-		const deferred = pending();
-		promise.then((value) => {
-			deferred.resolve(Result.succeed(value));
-		}, (error) => {
-			deferred.resolve(Result.fail(error));
-		});
-		next = deferred.promise;
-	}
-	resultThenables.set(promise, next);
-	return next;
-}
 function useQuery(factory, handle, options = {}) {
 	const client = useQueryClient();
 	const query = queryFor(client, factory, handle.input);
@@ -86,16 +45,16 @@ function useQuery(factory, handle, options = {}) {
 		whilePending
 	]);
 	QueryObserver.trackProp(observer, "promise");
-	const controls = withPromiseCommands(QueryObserver.trackResult(observer, result));
+	const controls = promiseControls(QueryObserver.trackResult(observer, result));
 	const throwOnError = options.throwOnError ?? client.throwOnError;
 	const withData = "data" in handle;
 	if (!throwOnError) {
-		const resultPromise = asResultThenable(result.promise);
+		const resultPromise = resultThenable(result.promise);
 		if (withData) return [use(resultPromise), controls];
-		return [resultPromise, controls];
+		return [QueryObserver.trackThenable(observer, resultPromise), controls];
 	}
 	if (withData) return [use(result.promise), controls];
-	return [result.promise, controls];
+	return [QueryObserver.trackThenable(observer, result.promise), controls];
 }
 //#endregion
 export { useQuery };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/react",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "React bindings for raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",
@@ -48,7 +48,7 @@
     }
   },
   "dependencies": {
-    "@raf-query/core": "0.10.0"
+    "@raf-query/core": "0.10.2"
   },
   "peerDependencies": {
     "@tanstack/react-router": "^1.170.0",

package/dist/all-keyed.d.mts

@@ -1,18 +0,0 @@
-//#region src/all-keyed.d.ts
-/** The resolved form of a record passed to {@link allKeyed}. */
-export type Settled<TRecord> = { -readonly [TKey in keyof TRecord]: Awaited<TRecord[TKey]>; };
-/**
- * Ponyfill of the TC39 `Promise.allKeyed` proposal: a record of promises in,
- * a promise of the same record out, rejecting on the first failure.
- *
- * ```ts
- * const data = await allKeyed({
- *   post: qc.ensure(postQuery, { slug }),
- *   author: qc.ensure(authorQuery, { slug }),
- * });
- * ```
- */
-export declare function allKeyed<TRecord extends {
-  readonly [key: string]: unknown;
-}>(record: TRecord): Promise<Settled<TRecord>>;
-//#endregion

package/dist/all-keyed.mjs

@@ -1,19 +0,0 @@
-//#region src/all-keyed.ts
-/**
-* Ponyfill of the TC39 `Promise.allKeyed` proposal: a record of promises in,
-* a promise of the same record out, rejecting on the first failure.
-*
-* ```ts
-* const data = await allKeyed({
-*   post: qc.ensure(postQuery, { slug }),
-*   author: qc.ensure(authorQuery, { slug }),
-* });
-* ```
-*/
-async function allKeyed(record) {
-	const keys = Object.keys(record);
-	const values = await Promise.all(keys.map((key) => record[key]));
-	return Object.fromEntries(keys.map((key, index) => [key, values[index]]));
-}
-//#endregion
-export { allKeyed };

package/dist/client.d.mts

@@ -1,124 +0,0 @@
-import { DataOf, DehydrateOptions, DehydratedState, HydrateOptions, InputArgs, InputOf, LoadOptions, PagedQueryFactory, Query, QueryCache, QueryFactory, QueryHandle, QueryHandleWithData } from "@raf-query/core";
-import { Effect, Layer } from "effect";
-//#region src/client.d.ts
-export interface QueryClientConfig<TServices = never> extends QueryCache.Config {
-  /**
-   * Services for queries whose `queryFn` returns an Effect. Built with the
-   * client, so it must build synchronously; `dispose()` runs its
-   * finalizers.
-   */
-  readonly layer?: Layer.Layer<TServices>;
-  /** Called with every failed request, including failed prefetches. */
-  onError?(error: unknown, query: Query.Query): void;
-  /**
-   * When `false`, `useQuery` for an Effect `queryFn` (a typed `ErrorOf`)
-   * returns a `Result` in the first tuple slot instead of a promise that
-   * rejects. Defaults to `false` when `layer` is set, `true` otherwise.
-   * Promise `queryFn`s always throw; this flag does not apply to them.
-   */
-  readonly throwOnError?: boolean;
-}
-/**
- * The query cache, with Promise methods. Create one per request on the
- * server and one per browser tab. `effect` is the same cache's Effect API.
- * Its verbs take factories whose `queryFn` needs at most `TServices`, the
- * services of `config.layer`.
- */
-export declare class QueryClient<TServices = never> {
-  #private;
-  /** The Effect-native cache behind this client. */
-  readonly effect: QueryCache.QueryCache;
-  readonly isServer: boolean;
-  /**
-   * Default for Effect `useQuery` reads. See
-   * {@link QueryClientConfig.throwOnError}.
-   */
-  readonly throwOnError: boolean;
-  constructor(config?: QueryClientConfig<TServices>);
-  /**
-   * The cache entry for a factory call, created if missing. Doesn't fetch.
-   * For bindings; apps use the verbs.
-   */
-  getQuery<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: InputArgs<TFactory>): Query.Query<TFactory>;
-  /**
-   * Start a query without waiting and return its handle. Fresh data is
-   * reused; stale data refetches in the background (in the browser only).
-   * Errors surface where the data is read, never here.
-   */
-  prefetch<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: InputArgs<TFactory>): QueryHandle<TFactory>;
-  /**
-   * {@link fetch} without waiting on stale data: start a query and wait for
-   * it on a cache miss. Stale cached data resolves immediately and
-   * revalidates in the browser. Rejects if that request fails.
-   */
-  ensure<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: InputArgs<TFactory>): Promise<QueryHandleWithData<TFactory>>;
-  /** {@link ensure}, loading `options.pages` pages of a paged query. */
-  ensure<TFactory extends PagedQueryFactory<TServices>>(factory: TFactory, input: InputOf<TFactory>, options: LoadOptions): Promise<QueryHandleWithData<TFactory>>;
-  /**
-   * Start a query and resolve to a handle holding its data. Waits on a cache
-   * miss and on stale data (on the server, only invalidated data), so the
-   * data is fresh. Rejects if that request fails.
-   */
-  fetch<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: InputArgs<TFactory>): Promise<QueryHandleWithData<TFactory>>;
-  /** {@link fetch}, loading `options.pages` pages of a paged query. */
-  fetch<TFactory extends PagedQueryFactory<TServices>>(factory: TFactory, input: InputOf<TFactory>, options: LoadOptions): Promise<QueryHandleWithData<TFactory>>;
-  /**
-   * Mark queries stale and refetch the ones being read. Resolves once those
-   * refetches settle, so an action stays pending until fresh data is on
-   * screen. Takes a factory and its input, or a {@link QueryCache.Filter}.
-   */
-  invalidate<TFactory extends QueryFactory<TServices>>(...target: QueryCache.Target<TFactory>): Promise<void>;
-  /**
-   * Drop queries' data and errors, as if they were never fetched. Read ones
-   * suspend and refetch; resolves once those refetches settle.
-   */
-  reset<TFactory extends QueryFactory<TServices>>(...target: QueryCache.Target<TFactory>): Promise<void>;
-  /**
-   * Remove queries from the cache and abort their requests. Readers keep the
-   * removed entry until they render again.
-   */
-  remove<TFactory extends QueryFactory<TServices>>(...target: QueryCache.Target<TFactory>): void;
-  /** Write data for a factory call. Readers re-render without suspending. */
-  setData<TFactory extends QueryFactory<TServices>>(factory: TFactory, input: InputOf<TFactory>, updater: QueryCache.Updater<DataOf<TFactory>>): void;
-  /**
-   * Cached data for a factory call, or `undefined` if there is none. Data can
-   * itself be `undefined`; `Query.getUnsafe(getQuery(...)).hasData` tells
-   * them apart.
-   */
-  getData<TFactory extends QueryFactory<TServices>>(factory: TFactory, ...args: InputArgs<TFactory>): DataOf<TFactory> | undefined;
-  /** Every entry, for devtools and integrations. */
-  getAll(): ReadonlyArray<Query.Query>;
-  /**
-   * How many entries have a request in flight: all of them, or those
-   * matching `filter`. For global loading indicators.
-   */
-  isFetching(filter?: QueryCache.Filter): number;
-  /** Listen to entries being added, updated, and removed. */
-  subscribe(listener: (event: QueryCache.Event) => void): () => void;
-  /** Drop every entry and abort in-flight requests. */
-  clear(): void;
-  /**
-   * Start refetching read, stale queries on window focus and reconnect.
-   * Returns the matching unmount. Providers call this; mounts are counted.
-   */
-  mount(): () => void;
-  /**
-   * Run an Effect with the cache (`QueryCache`) and the services of
-   * `config.layer`, as `Effect.runPromise` does: it rejects with the
-   * Effect's failure, or its defect. For an app's loaders and actions.
-   */
-  runPromise<A, E>(effect: Effect.Effect<A, E, QueryCache.QueryCache | TServices>): Promise<A>;
-  /**
-   * Close the client: interrupt every request and timer, and release the
-   * layer's services. Resolves once the layer's finalizers have run.
-   */
-  dispose(): Promise<void>;
-}
-/** Snapshot the cache for transfer to another client (server → browser). */
-export declare function dehydrate(client: QueryClient, options?: DehydrateOptions): DehydratedState;
-/**
- * Write dehydrated entries into a client. Existing entries only take newer
- * data; pending entries resume the sender's request.
- */
-export declare function hydrate(client: QueryClient, state: DehydratedState, options?: HydrateOptions): void;
-//#endregion

package/dist/client.mjs

@@ -1,176 +0,0 @@
-import { QueryCache } from "@raf-query/core";
-import { Context, Effect, Exit, Layer, Option, Predicate, Scope } from "effect";
-//#region src/client.ts
-/**
-* A verb's Effect, run by a client. Its requirement is the factory's
-* `ServicesOf`, which the client's verbs only accept when its `layer`
-* provides them.
-*/
-function provided(effect) {
-	return effect;
-}
-/**
-* Run a verb that waits on a request. A cancelled request rejects with an
-* `AbortError`, as an aborted `fetch` does, not with the Effect API's
-* `Query.CancelledError`.
-*/
-function runLoad(effect) {
-	return Effect.runPromise(effect).catch((error) => {
-		throw Predicate.isTagged(error, "CancelledError") ? new DOMException("The query was cancelled", "AbortError") : error;
-	});
-}
-/** `ensure` / `fetch` arguments, forwarded to the cache's same verb. */
-function loadArgs(input, options) {
-	return [input, options];
-}
-/**
-* The query cache, with Promise methods. Create one per request on the
-* server and one per browser tab. `effect` is the same cache's Effect API.
-* Its verbs take factories whose `queryFn` needs at most `TServices`, the
-* services of `config.layer`.
-*/
-var QueryClient = class {
-	/** The Effect-native cache behind this client. */
-	effect;
-	isServer;
-	/**
-	* Default for Effect `useQuery` reads. See
-	* {@link QueryClientConfig.throwOnError}.
-	*/
-	throwOnError;
-	/**
-	* The cache and the layer's services. Typed `never` so clients of any
-	* `TServices` stay assignable to each other; `runPromise` restores it.
-	*/
-	#context;
-	/**
-	* Owns the cache's fibers, mounts and the layer's services; lives until
-	* `dispose()`.
-	*/
-	#scope = Scope.makeUnsafe();
-	constructor(config = {}) {
-		const cache = QueryCache.layer(config);
-		const services = Effect.runSync(Layer.buildWithScope(config.layer ? Layer.provideMerge(cache, config.layer) : cache, this.#scope));
-		this.#context = services;
-		this.effect = Context.get(services, QueryCache.QueryCache);
-		this.isServer = this.effect.isServer;
-		this.throwOnError = config.throwOnError ?? config.layer === void 0;
-		const onError = config.onError;
-		if (onError) this.effect.subscribeUnsafe((event) => {
-			if (event.type === "failed") onError(event.error, event.query);
-		});
-	}
-	/**
-	* The cache entry for a factory call, created if missing. Doesn't fetch.
-	* For bindings; apps use the verbs.
-	*/
-	getQuery(factory, ...args) {
-		return this.effect.getQueryUnsafe(factory, ...args);
-	}
-	/**
-	* Start a query without waiting and return its handle. Fresh data is
-	* reused; stale data refetches in the background (in the browser only).
-	* Errors surface where the data is read, never here.
-	*/
-	prefetch(factory, ...args) {
-		return Effect.runSync(provided(this.effect.prefetch(factory, ...args)));
-	}
-	ensure(factory, input, options) {
-		return runLoad(provided(this.effect.ensure(factory, ...loadArgs(input, options))));
-	}
-	fetch(factory, input, options) {
-		return runLoad(provided(this.effect.fetch(factory, ...loadArgs(input, options))));
-	}
-	/**
-	* Mark queries stale and refetch the ones being read. Resolves once those
-	* refetches settle, so an action stays pending until fresh data is on
-	* screen. Takes a factory and its input, or a {@link QueryCache.Filter}.
-	*/
-	invalidate(...target) {
-		return Effect.runPromise(this.effect.invalidate(...target));
-	}
-	/**
-	* Drop queries' data and errors, as if they were never fetched. Read ones
-	* suspend and refetch; resolves once those refetches settle.
-	*/
-	reset(...target) {
-		return Effect.runPromise(this.effect.reset(...target));
-	}
-	/**
-	* Remove queries from the cache and abort their requests. Readers keep the
-	* removed entry until they render again.
-	*/
-	remove(...target) {
-		Effect.runSync(this.effect.remove(...target));
-	}
-	/** Write data for a factory call. Readers re-render without suspending. */
-	setData(factory, input, updater) {
-		Effect.runSync(this.effect.setData(factory, input, updater));
-	}
-	/**
-	* Cached data for a factory call, or `undefined` if there is none. Data can
-	* itself be `undefined`; `Query.getUnsafe(getQuery(...)).hasData` tells
-	* them apart.
-	*/
-	getData(factory, ...args) {
-		return Option.getOrUndefined(Effect.runSync(this.effect.getData(factory, ...args)));
-	}
-	/** Every entry, for devtools and integrations. */
-	getAll() {
-		return Effect.runSync(this.effect.all);
-	}
-	/**
-	* How many entries have a request in flight: all of them, or those
-	* matching `filter`. For global loading indicators.
-	*/
-	isFetching(filter) {
-		return this.effect.isFetchingUnsafe(filter);
-	}
-	/** Listen to entries being added, updated, and removed. */
-	subscribe(listener) {
-		return this.effect.subscribeUnsafe(listener);
-	}
-	/** Drop every entry and abort in-flight requests. */
-	clear() {
-		Effect.runSync(this.effect.clear);
-	}
-	/**
-	* Start refetching read, stale queries on window focus and reconnect.
-	* Returns the matching unmount. Providers call this; mounts are counted.
-	*/
-	mount() {
-		const scope = Scope.forkUnsafe(this.#scope);
-		Effect.runSync(this.effect.mount.pipe(Scope.provide(scope)));
-		return () => {
-			Effect.runSync(Scope.close(scope, Exit.void));
-		};
-	}
-	/**
-	* Run an Effect with the cache (`QueryCache`) and the services of
-	* `config.layer`, as `Effect.runPromise` does: it rejects with the
-	* Effect's failure, or its defect. For an app's loaders and actions.
-	*/
-	runPromise(effect) {
-		return Effect.runPromiseWith(this.#context)(effect);
-	}
-	/**
-	* Close the client: interrupt every request and timer, and release the
-	* layer's services. Resolves once the layer's finalizers have run.
-	*/
-	dispose() {
-		return Effect.runPromise(Scope.close(this.#scope, Exit.void));
-	}
-};
-/** Snapshot the cache for transfer to another client (server → browser). */
-function dehydrate(client, options) {
-	return Effect.runSync(client.effect.dehydrate(options));
-}
-/**
-* Write dehydrated entries into a client. Existing entries only take newer
-* data; pending entries resume the sender's request.
-*/
-function hydrate(client, state, options) {
-	Effect.runSync(client.effect.hydrate(state, options));
-}
-//#endregion
-export { QueryClient, dehydrate, hydrate };