@raf-query/react 0.2.8 → 0.3.1

package/CHANGELOG.md

@@ -1,8 +1,22 @@
 # Changelog
 
+## [0.3.1](https://github.com/KATT/raf-query/compare/0.3.0...0.3.1) (2026-10-13)
+
+* teach avoiding dependent queries; frame prefetch vs ensure as loading UX ([#62](https://github.com/KATT/raf-query/issues/62)) ([ec62760](https://github.com/KATT/raf-query/commit/ec627609cbbee9fa4ff0cf568f69964341e27daa))
+
+## [0.3.0](https://github.com/KATT/raf-query/compare/0.2.8...0.3.0) (2026-10-13)
+
+### ⚠ BREAKING CHANGES
+
+- RSC apps hydrate only through HydrationBoundary; QueryProvider moves to /rsc ([#61](https://github.com/KATT/raf-query/issues/61))
+
+### Features
+
+- RSC apps hydrate only through HydrationBoundary; QueryProvider moves to /rsc ([#61](https://github.com/KATT/raf-query/issues/61)) ([772de79](https://github.com/KATT/raf-query/commit/772de796adfdf267a9184fd75624ff30ae53f4fc)), references [#59](https://github.com/KATT/raf-query/issues/59) [#59](https://github.com/KATT/raf-query/issues/59) [#59](https://github.com/KATT/raf-query/issues/59) [#59](https://github.com/KATT/raf-query/issues/59)
+
 ## [0.2.8](https://github.com/KATT/raf-query/compare/0.2.7...0.2.8) (2026-10-13)
 
-* **codesandbox:** speed up the branch sync ([#60](https://github.com/KATT/raf-query/issues/60)) ([9099cb2](https://github.com/KATT/raf-query/commit/9099cb2ce937104d5feb8c7033233e701f412a28))
+- **codesandbox:** speed up the branch sync ([#60](https://github.com/KATT/raf-query/issues/60)) ([9099cb2](https://github.com/KATT/raf-query/commit/9099cb2ce937104d5feb8c7033233e701f412a28))
 
 ## [0.2.7](https://github.com/KATT/raf-query/compare/0.2.6...0.2.7) (2026-10-13)
 

package/README.md

@@ -32,12 +32,11 @@ The same issue tracker, built on two frameworks so the integrations can be compa
 
 `@raf-query/react` subpath entries for framework integrations and tooling:
 
-| Entry                              | Use                                                                    |
-| ---------------------------------- | ---------------------------------------------------------------------- |
-| `@raf-query/react/tanstack-router` | Streams the router's query cache to the client during SSR              |
-| `@raf-query/react/rsc`             | `HydrationBoundary` for passing server-component queries to the client |
-| `@raf-query/react/next`            | `QueryProvider` for Next.js App Router                                 |
-| `@raf-query/react/devtools`        | [Devtools](#devtools) panel for inspecting the cache in development    |
+| Entry                              | Use                                                                 |
+| ---------------------------------- | ------------------------------------------------------------------- |
+| `@raf-query/react/tanstack-router` | Streams the router's query cache to the client during SSR           |
+| `@raf-query/react/rsc`             | `QueryProvider` and `HydrationBoundary` for React Server Components |
+| `@raf-query/react/devtools`        | [Devtools](#devtools) panel for inspecting the cache in development |
 
 ## Principles
 
@@ -125,7 +124,7 @@ All three verbs live on the query client and accept a factory plus its input.
 | --------------------------------- | ----------------------------- | ------- | ---------------------------------------------------------------------- |
 | `qc.prefetch(factory, input)`     | `QueryHandle`                 | No      | Data the route can render without; it streams in                       |
 | `await qc.ensure(factory, input)` | `Promise<EnsuredQueryHandle>` | Yes     | Data the route must not render without; `useQuery` returns it directly |
-| `await qc.fetch(factory, input)`  | `Promise<Data>`               | Yes     | Rendering in a server component, or building another input             |
+| `await qc.fetch(factory, input)`  | `Promise<Data>`               | Yes     | Rendering data in a server component                                   |
 
 ```tsx
 // TanStack Start
@@ -140,6 +139,13 @@ export const Route = createFileRoute("/posts/$slug")({
 });
 ```
 
+`prefetch` and `ensure` start the request at the same moment, so neither is faster. They differ in what the user sees while it's in flight:
+
+- **`prefetch`: granular skeletons.** The navigation commits right away. Each part of the page that reads a query still loading suspends to its nearest Suspense boundary and fills in when its data streams in.
+- **`ensure`: a blocked navigation.** The previous page stays on screen until the data is in. In TanStack Router, a route with a `pendingComponent` shows it once `pendingMs` (1 second by default) has passed, which makes a full-page skeleton.
+
+Choose per query. `ensure` what the page can't lay out without, where a skeleton would only flash or shift (the post itself), and `prefetch` the rest (comments, sidebars, counts). Start every query before awaiting any of them, as the `prefetch` before the `await` above does, so a blocking query never delays the others.
+
 Await independent blocking queries together with `allKeyed`, which ships with raf-query. It's a 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
@@ -151,13 +157,74 @@ return await allKeyed({
 });
 ```
 
-Dependent inputs use `fetch`:
+### Avoid dependent queries
+
+A query whose input comes from another query's result can't start until that one has finished. That's a waterfall: one extra round trip per level, on every navigation. Fix it where the data is shaped, so every query a route needs starts from what the URL already holds:
+
+- **Put the input in the route.** If the page is about an organization, its id belongs in the path (`/orgs/$orgId`), not in a lookup on the current user.
+- **Have the backend resolve it.** The server already knows the session and the relations, so an endpoint can return the child with its parent, or be keyed by what the client has (`GET /me/org` instead of `GET /me` then `GET /orgs/:id`).
+
+<details>
+<summary>Example: the current user's organization</summary>
+
+A settings page needs the user and their organization, and the organization's id is a field of the user:
 
 ```ts
-const user = await qc.fetch(currentUserQuery);
-return { org: qc.prefetch(orgQuery, { orgId: user.orgId }) };
+export const Route = createFileRoute("/settings")({
+	loader: async (args) => {
+		const qc = args.context.queryClient;
+		const user = await qc.fetch(currentUserQuery);
+		return {
+			user: qc.prefetch(currentUserQuery),
+			org: qc.prefetch(orgQuery, { orgId: user.orgId }),
+		};
+	},
+});
 ```
 
+With a 150 ms round trip, the organization can't arrive before 300 ms, and the navigation is blocked for the first 150 even though nothing on the page needed the user that early. Each query keyed by the organization (members, billing) would add another 150.
+
+Fix it in the backend: the server can find the session's organization itself, so give it an endpoint and a query with no input.
+
+```ts
+export function currentOrgQuery() {
+	return queryOptions({
+		queryKey: ["org", "current"],
+		queryFn: () => getCurrentOrg(),
+	});
+}
+
+export const Route = createFileRoute("/settings")({
+	loader: (args) => {
+		const qc = args.context.queryClient;
+		return {
+			user: qc.prefetch(currentUserQuery),
+			org: qc.prefetch(currentOrgQuery),
+		};
+	},
+});
+```
+
+Or fix it in the routes: links into the page come from places that already know the organization (the org switcher, a list of orgs), so they can put its id in the URL.
+
+```ts
+export const Route = createFileRoute("/orgs/$orgId/settings")({
+	loader: (args) => {
+		const qc = args.context.queryClient;
+		return {
+			user: qc.prefetch(currentUserQuery),
+			org: qc.prefetch(orgQuery, { orgId: args.params.orgId }),
+		};
+	},
+});
+```
+
+Either way, both requests start together, and the page is ready after one round trip instead of two. Nothing waits, so each query can be a `prefetch` or an `ensure` purely for the loading experience you want.
+
+</details>
+
+When the data really can't be reshaped (a third-party API you don't control), the loader can `await qc.fetch(...)` the parent and build the input from its data, or a component can start the child with [`useWaterfall`](#render-time-inputs-usewaterfall). Both pay the extra round trip; the loader blocks the navigation on it, the component lets the rest of the page render first.
+
 Behavior:
 
 - Every verb dedupes against the cache. A fresh entry is reused; a stale entry is refetched in the background.
@@ -435,7 +502,7 @@ Like `prefetch` in a loader, `useWaterfall` refetches stale cached data in the b
 
 The name is the warning: each waterfall is an extra round trip after render. First try to get the input from route params so the loader can start it, or have the backend return it with its parent.
 
-During SSR the `queryFn` runs on the server. TanStack Start server functions work there. Next.js rejects server actions called while rendering, so in Next.js start the dependent query in the server component instead:
+In TanStack Start the `queryFn` runs on the server during SSR, and the router streams the result. Under the `/rsc` `QueryProvider` it starts nothing on the server: the reader's Suspense boundary renders its fallback there, and the query loads in the browser. To have it in the HTML, start the dependent query in the server component instead:
 
 ```tsx
 const post = await qc.fetch(postQuery, { slug });
@@ -518,7 +585,7 @@ export function getRouter() {
 
 `setupRouterIntegration` streams queries during SSR, clears the request's cache when the response finishes, and turns `redirect()` thrown from a `queryFn` into a router navigation. `getRouter` runs per request on the server, so each request gets its own client. Options: `dehydrateOptions` (`filter`, `keepErrors`, `serializeData`), `hydrateOptions` (`deserializeData`), and `handleRedirects: false` to handle redirects yourself. By default a server error crosses to the browser as a `RedactedError` naming the query, so its message doesn't leak into the page.
 
-### Next.js App Router
+### React Server Components (Next.js App Router)
 
 ```tsx
 // app/get-query-client.ts
@@ -530,7 +597,7 @@ export const getQueryClient = cache(() => new QueryClient());
 
 ```tsx
 // app/layout.tsx
-import { QueryProvider } from "@raf-query/react/next";
+import { QueryProvider } from "@raf-query/react/rsc";
 
 export default function RootLayout(props: { children: React.ReactNode }) {
 	return (
@@ -570,8 +637,9 @@ export default async function Page(props: {
 ```
 
 - `getQueryClient` is scoped to one request by React's `cache()`.
-- `HydrationBoundary` sends the request client's entries to the browser cache; pending ones stream as promises. Render one in each server component that starts queries for client components. Entries already sent in this request are skipped. The browser takes the server's data when it's newer than its own. Otherwise it keeps its copy and refetches it if stale. That covers a payload the router replays from its cache (back and forward) and a `prefetch` still pending on the server.
-- `QueryProvider` creates the browser client, and streams queries that client components start during SSR (`useWaterfall`) into the HTML. Pass `config` for the client's options; it must be serializable.
+- `HydrationBoundary` sends the request client's entries to the browser cache; pending ones stream as promises through the RSC payload. Render one in each server component that starts queries for client components. Entries already sent in this request are skipped.
+- The browser takes whichever copy is newer, by when it was fetched (`updatedAt`, so server and browser clocks should agree). When it has no data and no request of its own, it resumes the server's pending request. When it has data, or its own request in flight, it waits for the server's instead of fetching again, and takes it if newer. If it keeps its own copy (the server's is older, as in a payload the router replays from its cache on back and forward, or the server's request failed), it refetches it if stale.
+- `QueryProvider` creates one client per server render and one per browser tab. The server render starts no request: a client component reading a query no `HydrationBoundary` sent renders its Suspense fallback on the server, and the query loads in the browser. That boundary renders in the browser through React's error recovery, with the digest Next.js uses for `ssr: false`, so Next.js doesn't report it; other frameworks pass it to `onRecoverableError`. Pass `config` for the client's options; it must be serializable.
 - Server components that only render data can `await qc.fetch(...)` anywhere; the per-request client makes one request per query, whatever its `staleTime`.
 - `fetch` returns data, not a handle. When a server component renders the data and also hands the query to a client component, pass `await qc.ensure(...)`: after the `fetch` it resolves from the cache, and the client component gets the data from `useQuery` without a promise.
 - Factories can call server actions: server components call them directly, and the browser calls them on refetch. Validate their arguments, since anyone can call them. The browser runs a page's server actions one at a time, so refetches wait for each other and for any pending mutation. For parallel requests, have the `queryFn` call a [Route Handler](https://nextjs.org/docs/app/api-reference/file-conventions/route), as [`examples/nextjs`](examples/nextjs) does.

package/dist/browser-requests.mjs

@@ -0,0 +1,38 @@
+import { Query } from "@raf-query/core";
+//#region src/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.
+*/
+const clientRendering = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
+const browserOnly = /* @__PURE__ */ new WeakSet();
+/**
+* Make a server client's render start no request: it reads what a
+* `HydrationBoundary` sent, and anything else loads in the browser.
+*/
+function requestInBrowserOnly(client) {
+	browserOnly.add(client);
+}
+/** Whether a render may start `client`'s requests (`useWaterfall`). */
+function startsRequests(client) {
+	return !(client.isServer && browserOnly.has(client));
+}
+/**
+* Thrown by a server render's read of a query no `HydrationBoundary` sent.
+* React renders the nearest Suspense fallback, and the browser renders the
+* content.
+*/
+var BrowserRenderError = class extends Error {
+	digest = clientRendering;
+	constructor(hash) {
+		super(`Query ${hash} loads in the browser: no HydrationBoundary sent it`);
+	}
+};
+/** Throw {@link BrowserRenderError} if reading `query` would start a request here. */
+function assertSent(client, query) {
+	if (startsRequests(client)) return;
+	const state = Query.getUnsafe(query);
+	if (!state.hasData && !state.isFetching && state.status !== "error") throw new BrowserRenderError(query.hash);
+}
+//#endregion
+export { BrowserRenderError, assertSent, requestInBrowserOnly, startsRequests };

package/dist/hydrate.mjs

@@ -1,15 +1,9 @@
 "use client";
 import { hydrate } from "./client.mjs";
 import { useQueryClient } from "./provider.mjs";
-import { sentHashes } from "./sent.mjs";
 import { Query, hashKey } from "@raf-query/core";
 import { useEffect, useState } from "react";
 //#region src/hydrate.tsx
-/** In the SSR pass, entries from the RSC payload needn't be streamed again. */
-function markSent(client, state) {
-	const sent = sentHashes(client);
-	for (const query of state.queries) sent.add(hashKey(query.key));
-}
 /**
 * Entries the client has no data for, which children need during this
 * render, and entries it already shows, which must wait for a commit.
@@ -37,7 +31,6 @@ function Hydrate(props) {
 	const [hydrated, setHydrated] = useState();
 	if (hydrated?.state !== state) {
 		const parts = split(client, state);
-		markSent(client, state);
 		hydrate(client, parts.now, options);
 		setHydrated({
 			deferred: parts.deferred,

package/dist/query-provider.d.mts

@@ -0,0 +1,21 @@
+import { QueryClientConfig } from "./client.mjs";
+import { ReactNode } from "react";
+//#region src/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
+ * starts no request: client components read what `HydrationBoundary` sent,
+ * and a query nothing sent renders its Suspense fallback there and loads in
+ * the browser.
+ *
+ * ```tsx
+ * // app/layout.tsx
+ * <QueryProvider>{props.children}</QueryProvider>
+ * ```
+ */
+export declare function QueryProvider(props: {
+  readonly children?: ReactNode;
+  /** Options for the client it creates. */
+  readonly config?: QueryClientConfig;
+}): import("react").JSX.Element;
+//#endregion

package/dist/query-provider.mjs

@@ -0,0 +1,33 @@
+"use client";
+import { QueryClient } from "./client.mjs";
+import { QueryClientProvider } from "./provider.mjs";
+import { requestInBrowserOnly } from "./browser-requests.mjs";
+import { useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/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
+* starts no request: client components read what `HydrationBoundary` sent,
+* and a query nothing sent renders its Suspense fallback there and loads in
+* the browser.
+*
+* ```tsx
+* // app/layout.tsx
+* <QueryProvider>{props.children}</QueryProvider>
+* ```
+*/
+function QueryProvider(props) {
+	const config = props.config;
+	const [client] = useState(() => {
+		const created = new QueryClient(config);
+		requestInBrowserOnly(created);
+		return created;
+	});
+	return /* @__PURE__ */ jsx(QueryClientProvider, {
+		client,
+		children: props.children
+	});
+}
+//#endregion
+export { QueryProvider };

package/dist/rsc.d.mts

@@ -1,4 +1,5 @@
 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
@@ -23,4 +24,5 @@ export declare function HydrationBoundary(props: {
   readonly client: QueryClient;
   readonly options?: DehydrateOptions;
 }): import("react").JSX.Element;
-//#endregion
+//#endregion
+export { QueryProvider };

package/dist/rsc.mjs

@@ -1,6 +1,7 @@
 import { dehydrate } from "./client.mjs";
-import { sentHashes } from "./sent.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
 /**
@@ -30,4 +31,4 @@ function HydrationBoundary(props) {
 	});
 }
 //#endregion
-export { HydrationBoundary };
+export { HydrationBoundary, QueryProvider };

package/dist/sent.mjs

@@ -1,10 +1,8 @@
 //#region src/sent.ts
 const sentByClient = /* @__PURE__ */ new WeakMap();
 /**
-* Hashes of a client's entries that already have a way to the browser
-* cache: sent by an earlier `HydrationBoundary` of the request, or, in the
-* SSR pass, hydrated from the RSC payload or streamed by `QueryProvider`.
-* Integrations pass it as `sent`, so each entry crosses once.
+* Hashes of the request client's entries an earlier `HydrationBoundary`
+* already sent. Boundaries pass it as `sent`, so each entry crosses once.
 */
 function sentHashes(client) {
 	let sent = sentByClient.get(client);

package/dist/use-query.mjs

@@ -1,6 +1,7 @@
 "use client";
 import { unsafeCast } from "./cast.mjs";
 import { useQueryClient } from "./provider.mjs";
+import { assertSent } from "./browser-requests.mjs";
 import { Query, QueryObserver } from "@raf-query/core";
 import { Effect } from "effect";
 import { use, useEffect, useState, useSyncExternalStore } from "react";
@@ -35,7 +36,9 @@ function storeFor(query, options) {
 	};
 }
 function useQuery(factory, handle, options = {}) {
-	const query = queryFor(useQueryClient(), factory, handle.input);
+	const client = useQueryClient();
+	const query = queryFor(client, factory, handle.input);
+	assertSent(client, query);
 	Query.readUnsafe(query);
 	const refetchInterval = options.refetchInterval;
 	const refetchOnReconnect = options.refetchOnReconnect;

package/dist/use-waterfall.d.mts

@@ -5,7 +5,9 @@ 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.
+ * background, once per mount and input. Under the `/rsc` `QueryProvider` it
+ * starts nothing on the server: the reader's Suspense boundary renders its
+ * fallback there, and the query loads in the browser.
  *
  * ```tsx
  * const author = useWaterfall(authorQuery, { id: post.authorId });

package/dist/use-waterfall.mjs

@@ -1,5 +1,6 @@
 "use client";
 import { useQueryClient } from "./provider.mjs";
+import { startsRequests } from "./browser-requests.mjs";
 import { Query } from "@raf-query/core";
 import { useState } from "react";
 //#region src/use-waterfall.ts
@@ -14,7 +15,9 @@ 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.
+* background, once per mount and input. Under the `/rsc` `QueryProvider` it
+* starts nothing on the server: the reader's Suspense boundary renders its
+* fallback there, and the query loads in the browser.
 *
 * ```tsx
 * const author = useWaterfall(authorQuery, { id: post.authorId });
@@ -22,9 +25,11 @@ const waitedFor = /* @__PURE__ */ new WeakSet();
 * ```
 */
 function useWaterfall(factory, ...args) {
-	const query = useQueryClient().getQuery(factory, ...args);
-	const promise = Query.readUnsafe(query);
+	const client = useQueryClient();
+	const query = client.getQuery(factory, ...args);
 	const [started, setStarted] = useState();
+	if (!startsRequests(client)) return query.handle;
+	const promise = Query.readUnsafe(query);
 	if (started !== query.hash) {
 		if (!Query.getUnsafe(query).hasData) waitedFor.add(promise);
 		else if (!waitedFor.delete(promise)) Query.revalidateUnsafe(query);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/react",
-  "version": "0.2.8",
+  "version": "0.3.1",
   "description": "React bindings for raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",
@@ -35,7 +35,6 @@
     ".": "./dist/index.mjs",
     "./devtools": "./dist/devtools.mjs",
     "./devtools/production": "./dist/devtools-production.mjs",
-    "./next": "./dist/next.mjs",
     "./rsc": "./dist/rsc.mjs",
     "./tanstack-router": {
       "workerd": "./dist/tanstack-router.mjs",
@@ -48,20 +47,16 @@
     }
   },
   "dependencies": {
-    "@raf-query/core": "0.2.8"
+    "@raf-query/core": "0.3.1"
   },
   "peerDependencies": {
     "@tanstack/react-router": "^1.170.0",
     "effect": "^4.0.0",
-    "next": "^16.0.0",
     "react": "^19.2.0"
   },
   "peerDependenciesMeta": {
     "@tanstack/react-router": {
       "optional": true
-    },
-    "next": {
-      "optional": true
     }
   },
   "devDependencies": {
@@ -74,7 +69,6 @@
     "@vitest/coverage-v8": "5.0.1",
     "effect": "^4.0.1",
     "happy-dom": "21.0.1",
-    "next": "16.4.0",
     "react": "19.3.0",
     "react-dom": "19.3.0",
     "typescript": "7.0.2",

package/dist/next.d.mts

@@ -1,25 +0,0 @@
-import { QueryClientConfig } from "./client.mjs";
-import { DehydratedState } from "@raf-query/core";
-import { ReactNode } from "react";
-//#region src/next.d.ts
-declare global {
-  /** Entries streamed by `QueryProvider` during SSR, until the browser client takes over. */
-  var RAF_QUERY_SSR: {
-    push(state: DehydratedState): void;
-  } | undefined;
-}
-/**
- * The query client provider for Next.js App Router. Creates one client per
- * request during SSR and one per tab in the browser.
- *
- * ```tsx
- * // app/layout.tsx
- * <QueryProvider>{props.children}</QueryProvider>
- * ```
- */
-export declare function QueryProvider(props: {
-  readonly children?: ReactNode;
-  /** Options for the client it creates. */
-  readonly config?: QueryClientConfig;
-}): import("react").JSX.Element;
-//#endregion

package/dist/next.mjs

@@ -1,62 +0,0 @@
-"use client";
-import { QueryClient, dehydrate, hydrate } from "./client.mjs";
-import { QueryClientProvider } from "./provider.mjs";
-import { sentHashes } from "./sent.mjs";
-import { Query } from "@raf-query/core";
-import { useState } from "react";
-import { jsx } from "react/jsx-runtime";
-import { useServerInsertedHTML } from "next/navigation";
-//#region src/next.tsx
-function escapeJson(json) {
-	return json.replaceAll("<", String.raw`\u003c`).replaceAll("\u2028", String.raw`\u2028`).replaceAll("\u2029", String.raw`\u2029`);
-}
-/** Hydrate what SSR streamed so far, then hydrate every later chunk on arrival. */
-function receiveStream(client) {
-	const queued = globalThis.RAF_QUERY_SSR;
-	if (Array.isArray(queued)) for (const state of queued) hydrate(client, state);
-	globalThis.RAF_QUERY_SSR = { push: (state) => hydrate(client, state) };
-}
-function hasData(query) {
-	return Query.getUnsafe(query).hasData;
-}
-/**
-* Streams entries that client components loaded during SSR (`useWaterfall`)
-* into the HTML, ahead of the markup that reads them. Entries that arrived
-* through `HydrationBoundary` are skipped: the RSC payload carries them.
-* Data must be JSON-serializable, so only settled entries are sent.
-*/
-function useServerStream(client) {
-	useServerInsertedHTML(() => {
-		const state = dehydrate(client, {
-			filter: hasData,
-			sent: sentHashes(client)
-		});
-		if (state.queries.length === 0) return null;
-		const json = escapeJson(JSON.stringify(state));
-		return /* @__PURE__ */ jsx("script", { dangerouslySetInnerHTML: { __html: `(self.RAF_QUERY_SSR=self.RAF_QUERY_SSR||[]).push(${json})` } });
-	});
-}
-/**
-* The query client provider for Next.js App Router. Creates one client per
-* request during SSR and one per tab in the browser.
-*
-* ```tsx
-* // app/layout.tsx
-* <QueryProvider>{props.children}</QueryProvider>
-* ```
-*/
-function QueryProvider(props) {
-	const config = props.config;
-	const [client] = useState(() => {
-		const created = new QueryClient(config);
-		if (!created.isServer) receiveStream(created);
-		return created;
-	});
-	useServerStream(client);
-	return /* @__PURE__ */ jsx(QueryClientProvider, {
-		client,
-		children: props.children
-	});
-}
-//#endregion
-export { QueryProvider };