@raf-query/react 0.9.2 → 0.10.0

package/CHANGELOG.md

@@ -1,10 +1,26 @@
 # Changelog
 
+## [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`                 | `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                                        |
 
 ## License
 

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

@@ -1,9 +1,9 @@
 "use client";
-import { hydrate } from "./client.mjs";
-import { useQueryClient } from "./provider.mjs";
+import { hydrate } from "../client.mjs";
+import { useQueryClient } from "../provider.mjs";
 import { Query, hashKey } 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 { dehydrate } from "../client.mjs";
+import { Hydrate } from "./hydrate.mjs";
+import { sentHashes } from "./sent.mjs";
+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,65 @@
+import { QueryClient } from "../client.mjs";
+import { DehydrateOptions, DehydratedState, HydrateOptions } 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,11 @@
+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 { 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 };

package/dist/index-react-server.mjs

@@ -0,0 +1,10 @@
+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-react-server.mjs";
+export * from "@raf-query/core";
+export { HydrationBoundary, QueryClient, QueryClientProvider, QueryProvider, allKeyed, dehydrate, hydrate, useIsFetching, useQuery, useQueryClient, useWaterfall };

package/dist/index-shared.d.mts

@@ -0,0 +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 { 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 };

package/dist/index-shared.mjs

@@ -0,0 +1,9 @@
+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 };

package/dist/index.d.mts

@@ -1,8 +1,11 @@
 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 { 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 { 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 };

package/dist/index.mjs

@@ -1,8 +1,10 @@
 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, QueryClient, QueryClientProvider, QueryProvider, allKeyed, dehydrate, hydrate, useIsFetching, useQuery, useQueryClient, useWaterfall };

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 "../client.mjs";
 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 { 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
+//#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/use-query.mjs

@@ -1,6 +1,6 @@
 "use client";
 import { useQueryClient } from "./provider.mjs";
-import { assertSent } from "./browser-requests.mjs";
+import { assertSent } from "./query-provider/browser-requests.mjs";
 import { Query, QueryObserver, fulfilled, pending } from "@raf-query/core";
 import { Effect, Result } from "effect";
 import { use, useEffect, useState, useSyncExternalStore } from "react";

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.0",
   "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.0"
   },
   "peerDependencies": {
     "@tanstack/react-router": "^1.170.0",

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 };