@raf-query/react 0.9.2 → 0.10.1

package/CHANGELOG.md

@@ -1,10 +1,36 @@
 # Changelog
 
+## [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))
+
+### 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)
+
+### 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)
+
 ## [0.9.2](https://github.com/KATT/raf-query/compare/0.9.1...0.9.2) (2026-10-15)
 
 ### Bug Fixes
 
-* **core:** keep handles of factories with the same signature apart ([#167](https://github.com/KATT/raf-query/issues/167)) ([5894bcb](https://github.com/KATT/raf-query/commit/5894bcbcc382c60e9c04768c0e178bf0996f4b45))
+- **core:** keep handles of factories with the same signature apart ([#167](https://github.com/KATT/raf-query/issues/167)) ([5894bcb](https://github.com/KATT/raf-query/commit/5894bcbcc382c60e9c04768c0e178bf0996f4b45))
 
 ## [0.9.1](https://github.com/KATT/raf-query/compare/0.9.0...0.9.1) (2026-10-15)
 

package/README.md

@@ -124,13 +124,11 @@ function PostPage() {
 
 ## Entry points
 
-| Import                             | Use                                                                                                |
-| ---------------------------------- | -------------------------------------------------------------------------------------------------- |
-| `@raf-query/react`                 | `QueryClient`, `QueryClientProvider`, `useQuery`, `useWaterfall`, `useIsFetching`, 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/rsc`             | [React Server Components](https://raf-query.katt.dev/docs/nextjs), such as the Next.js App Router  |
-| `@raf-query/react/react-router`    | [React Router](https://raf-query.katt.dev/docs/react-router) Framework Mode loaders                |
-| `@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/{hydrate.mjs → hydration-boundary/hydrate.mjs}

@@ -1,9 +1,8 @@
 "use client";
-import { hydrate } from "./client.mjs";
-import { useQueryClient } from "./provider.mjs";
-import { Query, hashKey } from "@raf-query/core";
+import { useQueryClient } from "../provider.mjs";
+import { Query, hashKey, hydrate } from "@raf-query/core";
 import { useEffect, useState } from "react";
-//#region src/hydrate.tsx
+//#region src/hydration-boundary/hydrate.tsx
 /**
 * Entries the client has no data for, which children need during this
 * render, and entries it already shows, which must wait for a commit.

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

@@ -0,0 +1,11 @@
+import { HydrationBoundaryProps } from "./hydration-boundary.mjs";
+//#region src/hydration-boundary/hydration-boundary-react-server.d.ts
+/**
+ * `HydrationBoundary` in server components (the `react-server` export
+ * condition). With `client`, sends the request client's entries to the
+ * browser cache: pending entries cross as promises and stream in as they
+ * settle, and entries an earlier boundary already sent in this request are
+ * skipped. With `state`, writes that state, as the browser version does.
+ */
+export declare function HydrationBoundary(props: HydrationBoundaryProps): import("react").JSX.Element;
+//#endregion

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

@@ -0,0 +1,30 @@
+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
+/**
+* `HydrationBoundary` in server components (the `react-server` export
+* condition). With `client`, sends the request client's entries to the
+* browser cache: pending entries cross as promises and stream in as they
+* settle, and entries an earlier boundary already sent in this request are
+* skipped. With `state`, writes that state, as the browser version does.
+*/
+function HydrationBoundary(props) {
+	if (props.client === void 0) return /* @__PURE__ */ jsx(Hydrate, {
+		options: props.options,
+		state: props.state,
+		children: props.children
+	});
+	const client = props.client;
+	const state = dehydrate(client, {
+		sent: sentHashes(client),
+		...props.options
+	});
+	return /* @__PURE__ */ jsx(Hydrate, {
+		state,
+		children: props.children
+	});
+}
+//#endregion
+export { HydrationBoundary };

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

@@ -0,0 +1,64 @@
+import { DehydrateOptions, DehydratedState, HydrateOptions, QueryClient } from "@raf-query/core";
+import { ReactNode } from "react";
+//#region src/hydration-boundary/hydration-boundary.d.ts
+export type HydrationBoundaryProps = {
+  readonly children?: ReactNode;
+  /**
+   * The request's server client (e.g. from React's `cache()`). Server
+   * components only.
+   */
+  readonly client: QueryClient;
+  readonly options?: DehydrateOptions;
+  readonly state?: never;
+} | {
+  readonly children?: ReactNode;
+  readonly client?: never;
+  readonly options?: HydrateOptions;
+  /** A loader's `dehydrate(qc)`. */
+  readonly state: DehydratedState;
+};
+/**
+ * Writes server data into the browser (or SSR) client.
+ *
+ * In a server component, pass the request's `client`. Its entries go
+ * through the RSC payload: pending entries cross as promises and stream in
+ * as they settle, and entries an earlier boundary already sent in this
+ * request are skipped. Server components get that build of the component
+ * through the package's `react-server` export condition.
+ *
+ * ```tsx
+ * const qc = getQueryClient();
+ * const comments = qc.prefetch(commentsQuery, { slug });
+ * return (
+ *   <HydrationBoundary client={qc}>
+ *     <Comments handle={comments} />
+ *   </HydrationBoundary>
+ * );
+ * ```
+ *
+ * With loaders, such as React Router Framework Mode, pass the `state` the
+ * loader dehydrated:
+ *
+ * ```tsx
+ * export async function loader(args: Route.LoaderArgs) {
+ *   const qc = new QueryClient();
+ *   const post = await qc.ensure(postQuery, { slug: args.params.slug });
+ *   return { dehydratedState: dehydrate(qc), post };
+ * }
+ *
+ * export default function Page(props: Route.ComponentProps) {
+ *   const { dehydratedState, post } = props.loaderData;
+ *   return (
+ *     <HydrationBoundary state={dehydratedState}>
+ *       <Post handle={post} />
+ *     </HydrationBoundary>
+ *   );
+ * }
+ * ```
+ *
+ * Pending entries cross as promises when the framework's serializer
+ * supports them (React Router's Single Fetch does). Nested boundaries
+ * are fine: each only writes what its `state` holds.
+ */
+export declare function HydrationBoundary(props: HydrationBoundaryProps): import("react").JSX.Element;
+//#endregion

package/dist/{react-router.mjs → hydration-boundary/hydration-boundary.mjs}

@@ -1,11 +1,28 @@
 "use client";
 import { Hydrate } from "./hydrate.mjs";
 import { jsx } from "react/jsx-runtime";
-//#region src/react-router.tsx
+//#region src/hydration-boundary/hydration-boundary.tsx
 /**
-* Writes a loader's dehydrated cache into the browser (or SSR) client.
-* Use it with React Router Framework Mode: start queries in the loader,
-* `dehydrate` the request's client, and pass that state here.
+* Writes server data into the browser (or SSR) client.
+*
+* In a server component, pass the request's `client`. Its entries go
+* through the RSC payload: pending entries cross as promises and stream in
+* as they settle, and entries an earlier boundary already sent in this
+* request are skipped. Server components get that build of the component
+* through the package's `react-server` export condition.
+*
+* ```tsx
+* const qc = getQueryClient();
+* const comments = qc.prefetch(commentsQuery, { slug });
+* return (
+*   <HydrationBoundary client={qc}>
+*     <Comments handle={comments} />
+*   </HydrationBoundary>
+* );
+* ```
+*
+* With loaders, such as React Router Framework Mode, pass the `state` the
+* loader dehydrated:
 *
 * ```tsx
 * export async function loader(args: Route.LoaderArgs) {
@@ -29,6 +46,7 @@ import { jsx } from "react/jsx-runtime";
 * are fine: each only writes what its `state` holds.
 */
 function HydrationBoundary(props) {
+	if (props.state === void 0) throw new Error("HydrationBoundary needs `state` here. `client` works only in server components.");
 	return /* @__PURE__ */ jsx(Hydrate, {
 		options: props.options,
 		state: props.state,

package/dist/{sent.mjs → hydration-boundary/sent.mjs}

@@ -1,4 +1,4 @@
-//#region src/sent.ts
+//#region src/hydration-boundary/sent.ts
 const sentByClient = /* @__PURE__ */ new WeakMap();
 /**
 * Hashes of the request client's entries an earlier `HydrationBoundary`

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

@@ -0,0 +1,9 @@
+import { QueryClientProvider, useQueryClient } from "./provider.mjs";
+import { QueryProvider } from "./query-provider/query-provider.mjs";
+import { useIsFetching } from "./use-is-fetching.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 { HydrationBoundary, QueryClientProvider, QueryProvider, type UseQueryResult, type UseQueryResultWithData, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index-react-server.mjs

@@ -0,0 +1,8 @@
+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";
+import { HydrationBoundary } from "./hydration-boundary/hydration-boundary-react-server.mjs";
+export * from "@raf-query/core";
+export { HydrationBoundary, QueryClientProvider, QueryProvider, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index-shared.d.mts

@@ -0,0 +1,7 @@
+import { QueryClientProvider, useQueryClient } from "./provider.mjs";
+import { QueryProvider } from "./query-provider/query-provider.mjs";
+import { useIsFetching } from "./use-is-fetching.mjs";
+import { UseQueryResult, UseQueryResultWithData, useQuery } from "./use-query.mjs";
+import { useWaterfall } from "./use-waterfall.mjs";
+export * from "@raf-query/core";
+export { QueryClientProvider, QueryProvider, type UseQueryResult, type UseQueryResultWithData, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index-shared.mjs

@@ -0,0 +1,7 @@
+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 { QueryClientProvider, QueryProvider, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index.d.mts

@@ -1,8 +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, type PagingControls, QueryClient, type QueryClientConfig, QueryClientProvider, type QueryControls, 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,8 +1,8 @@
-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";
+import { HydrationBoundary } from "./hydration-boundary/hydration-boundary.mjs";
 export * from "@raf-query/core";
-export { QueryClient, QueryClientProvider, 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/{browser-requests.mjs → query-provider/browser-requests.mjs}

@@ -1,5 +1,5 @@
 import { Query } from "@raf-query/core";
-//#region src/browser-requests.ts
+//#region src/query-provider/browser-requests.ts
 /**
 * The digest Next.js gives a boundary that renders only in the browser
 * (`next/dynamic` with `ssr: false`); it doesn't report those errors.

package/dist/{query-provider.d.mts → query-provider/query-provider.d.mts}

@@ -1,6 +1,6 @@
-import { QueryClientConfig } from "./client.mjs";
+import { QueryClientConfig } from "@raf-query/core";
 import { ReactNode } from "react";
-//#region src/query-provider.d.ts
+//#region src/query-provider/query-provider.d.ts
 /**
  * The query client provider for React Server Components apps. Creates one
  * client per server render and one per browser tab. The server render

package/dist/{query-provider.mjs → query-provider/query-provider.mjs}

@@ -1,10 +1,10 @@
 "use client";
-import { QueryClient } from "./client.mjs";
-import { QueryClientProvider } from "./provider.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.tsx
+//#region src/query-provider/query-provider.tsx
 /**
 * The query client provider for React Server Components apps. Creates one
 * client per server render and one per browser tab. The server render

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,67 +1,6 @@
-import { DataOf, ErrorOf, InputOf, IsPaged, QueryFactory, QueryHandle, QueryHandleWithData, QueryKey, QueryObserver } from "@raf-query/core";
+import { DataOf, ErrorOf, QueryFactory, QueryHandle, QueryHandleWithData, 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>];
 /** {@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>];

package/dist/use-query.mjs

@@ -1,31 +1,13 @@
 "use client";
 import { useQueryClient } from "./provider.mjs";
-import { assertSent } from "./browser-requests.mjs";
-import { Query, QueryObserver, fulfilled, pending } from "@raf-query/core";
-import { Effect, Result } from "effect";
+import { assertSent } from "./query-provider/browser-requests.mjs";
+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,11 +45,11 @@ 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];
 	}

package/dist/use-waterfall.d.mts

@@ -5,7 +5,7 @@ import { InputArgs, QueryFactory, QueryHandle } from "@raf-query/core";
  * at render time (an id from a parent query's data). Each call is a request
  * waterfall: prefer starting the query in a loader or server component.
  * Like `prefetch` in a loader, it refetches stale cached data in the
- * background, once per mount and input. Under the `/rsc` `QueryProvider` it
+ * background, once per mount and input. Under `QueryProvider` it
  * starts nothing on the server: the reader's Suspense boundary renders its
  * fallback there, and the query loads in the browser.
  *

package/dist/use-waterfall.mjs

@@ -1,6 +1,6 @@
 "use client";
 import { useQueryClient } from "./provider.mjs";
-import { startsRequests } from "./browser-requests.mjs";
+import { startsRequests } from "./query-provider/browser-requests.mjs";
 import { Query } from "@raf-query/core";
 import { useState } from "react";
 //#region src/use-waterfall.ts
@@ -15,7 +15,7 @@ const waitedFor = /* @__PURE__ */ new WeakSet();
 * at render time (an id from a parent query's data). Each call is a request
 * waterfall: prefer starting the query in a loader or server component.
 * Like `prefetch` in a loader, it refetches stale cached data in the
-* background, once per mount and input. Under the `/rsc` `QueryProvider` it
+* background, once per mount and input. Under `QueryProvider` it
 * starts nothing on the server: the reader's Suspense boundary renders its
 * fallback there, and the query loads in the browser.
 *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/react",
-  "version": "0.9.2",
+  "version": "0.10.1",
   "description": "React bindings for raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",
@@ -32,10 +32,11 @@
   "type": "module",
   "sideEffects": false,
   "exports": {
-    ".": "./dist/index.mjs",
+    ".": {
+      "react-server": "./dist/index-react-server.mjs",
+      "default": "./dist/index.mjs"
+    },
     "./devtools": "./dist/devtools.mjs",
-    "./rsc": "./dist/rsc.mjs",
-    "./react-router": "./dist/react-router.mjs",
     "./tanstack-router": {
       "workerd": "./dist/tanstack-router.mjs",
       "worker": "./dist/tanstack-router.mjs",
@@ -47,7 +48,7 @@
     }
   },
   "dependencies": {
-    "@raf-query/core": "0.9.2"
+    "@raf-query/core": "0.10.1"
   },
   "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 };

package/dist/react-router.d.mts

@@ -1,35 +0,0 @@
-import { DehydratedState, HydrateOptions } from "@raf-query/core";
-import { ReactNode } from "react";
-//#region src/react-router.d.ts
-/**
- * Writes a loader's dehydrated cache into the browser (or SSR) client.
- * Use it with React Router Framework Mode: start queries in the loader,
- * `dehydrate` the request's client, and pass that state here.
- *
- * ```tsx
- * export async function loader(args: Route.LoaderArgs) {
- *   const qc = new QueryClient();
- *   const post = await qc.ensure(postQuery, { slug: args.params.slug });
- *   return { dehydratedState: dehydrate(qc), post };
- * }
- *
- * export default function Page(props: Route.ComponentProps) {
- *   const { dehydratedState, post } = props.loaderData;
- *   return (
- *     <HydrationBoundary state={dehydratedState}>
- *       <Post handle={post} />
- *     </HydrationBoundary>
- *   );
- * }
- * ```
- *
- * Pending entries cross as promises when the framework's serializer
- * supports them (React Router's Single Fetch does). Nested boundaries
- * are fine: each only writes what its `state` holds.
- */
-export declare function HydrationBoundary(props: {
-  readonly children?: ReactNode;
-  readonly options?: HydrateOptions;
-  readonly state: DehydratedState;
-}): import("react").JSX.Element;
-//#endregion

package/dist/rsc.d.mts

@@ -1,28 +0,0 @@
-import { QueryClient } from "./client.mjs";
-import { QueryProvider } from "./query-provider.mjs";
-import { DehydrateOptions } from "@raf-query/core";
-import { ReactNode } from "react";
-//#region src/rsc.d.ts
-/**
- * Server component: sends the request client's entries to the browser cache.
- * Pending entries cross as promises and stream in as they settle. Entries an
- * earlier boundary already sent in this request are skipped.
- *
- * ```tsx
- * const qc = getQueryClient();
- * const comments = qc.prefetch(commentsQuery, { slug });
- * return (
- *   <HydrationBoundary client={qc}>
- *     <Comments handle={comments} />
- *   </HydrationBoundary>
- * );
- * ```
- */
-export declare function HydrationBoundary(props: {
-  readonly children?: ReactNode;
-  /** The request's server client (e.g. from React's `cache()`). */
-  readonly client: QueryClient;
-  readonly options?: DehydrateOptions;
-}): import("react").JSX.Element;
-//#endregion
-export { QueryProvider };

package/dist/rsc.mjs

@@ -1,34 +0,0 @@
-import { dehydrate } from "./client.mjs";
-import { Hydrate } from "./hydrate.mjs";
-import { sentHashes } from "./sent.mjs";
-import { QueryProvider } from "./query-provider.mjs";
-import { jsx } from "react/jsx-runtime";
-//#region src/rsc.tsx
-/**
-* Server component: sends the request client's entries to the browser cache.
-* Pending entries cross as promises and stream in as they settle. Entries an
-* earlier boundary already sent in this request are skipped.
-*
-* ```tsx
-* const qc = getQueryClient();
-* const comments = qc.prefetch(commentsQuery, { slug });
-* return (
-*   <HydrationBoundary client={qc}>
-*     <Comments handle={comments} />
-*   </HydrationBoundary>
-* );
-* ```
-*/
-function HydrationBoundary(props) {
-	const client = props.client;
-	const state = dehydrate(client, {
-		sent: sentHashes(client),
-		...props.options
-	});
-	return /* @__PURE__ */ jsx(Hydrate, {
-		state,
-		children: props.children
-	});
-}
-//#endregion
-export { HydrationBoundary, QueryProvider };