@raf-query/core 0.12.0 → 0.13.1

package/CHANGELOG.md

@@ -1,14 +1,48 @@
 # Changelog
 
+## [0.13.1](https://github.com/KATT/raf-query/compare/0.13.0...0.13.1) (2026-11-10)
+
+### Features
+
+* **core:** keepPages, for lists whose start stays out of the key ([#248](https://github.com/KATT/raf-query/issues/248)) ([164c88c](https://github.com/KATT/raf-query/commit/164c88c4509a34c9ec51f089c3b70c03ea13cac0))
+
+## [0.13.0](https://github.com/KATT/raf-query/compare/0.12.0...0.13.0) (2026-11-10)
+
+### ⚠ BREAKING CHANGES
+
+- **core:** paging lives in core; useInfiniteQuery reads core's PageControls ([#246](https://github.com/KATT/raf-query/issues/246))
+
+### Features
+
+- **core:** paging lives in core; useInfiniteQuery reads core's PageControls ([#246](https://github.com/KATT/raf-query/issues/246)) ([f6b4ed2](https://github.com/KATT/raf-query/commit/f6b4ed210340b4b25bf3316ef08a9c8ceb9ed112))
+- **core:** pass the client making the request to queryFn ([#241](https://github.com/KATT/raf-query/issues/241)) ([8c85746](https://github.com/KATT/raf-query/commit/8c85746c230bc3d8a426b32a130a260fa7e8ca62))
+- **core:** replay cached entries to a new client subscriber ([#243](https://github.com/KATT/raf-query/issues/243)) ([1455eed](https://github.com/KATT/raf-query/commit/1455eed2612fe69f0f10bfec08cfd552ef90c786))
+- **core:** ssr: false for queries only a browser can run ([#240](https://github.com/KATT/raf-query/issues/240)) ([077de62](https://github.com/KATT/raf-query/commit/077de6223a92b8bd8d35f7df043d1efe147ca403))
+
+### Bug Fixes
+
+- **core:** infer factories built inline by a generic maker in setData ([#244](https://github.com/KATT/raf-query/issues/244)) ([da87c07](https://github.com/KATT/raf-query/commit/da87c07a3463a919c154ac3ac5fba3d546b3231e))
+- **core:** keep data written while a request ran ([#239](https://github.com/KATT/raf-query/issues/239)) ([4cb7cc0](https://github.com/KATT/raf-query/commit/4cb7cc0605a2d4637591eb365153c5e955eb41a8))
+- **core:** start features once for providers that share a client ([#242](https://github.com/KATT/raf-query/issues/242)) ([d5968fb](https://github.com/KATT/raf-query/commit/d5968fb140429a1b2e7fb94662c266a52e877cc0))
+
+### Documentation
+
+- every example is the blog's posts, comments and authors ([#236](https://github.com/KATT/raf-query/issues/236)) ([2551e97](https://github.com/KATT/raf-query/commit/2551e9710aa7b149be333a1675dae31d9d1f5efd)), references [#230](https://github.com/KATT/raf-query/issues/230)
+
+### Miscellaneous Chores
+
+- **lint:** require a docs link on every public export ([#237](https://github.com/KATT/raf-query/issues/237)) ([b5c8133](https://github.com/KATT/raf-query/commit/b5c8133c129e0412e82cd2f24da6a2516b4a2012))
+- unblock CI: [@see](https://github.com/see) links and the RSC test's build ([#245](https://github.com/KATT/raf-query/issues/245)) ([84927e4](https://github.com/KATT/raf-query/commit/84927e4a900f7608e1e17b022e28afadbe00e4ae)), references [#243](https://github.com/KATT/raf-query/issues/243) [#246](https://github.com/KATT/raf-query/issues/246) [#240](https://github.com/KATT/raf-query/issues/240) [#238](https://github.com/KATT/raf-query/issues/238)
+
 ## [0.12.0](https://github.com/KATT/raf-query/compare/0.11.1...0.12.0) (2026-11-08)
 
 ### ⚠ BREAKING CHANGES
 
-* greenfield rewrite on a promise kernel, with load() handles and opt-in behaviors ([#230](https://github.com/KATT/raf-query/issues/230))
+- greenfield rewrite on a promise kernel, with load() handles and opt-in behaviors ([#230](https://github.com/KATT/raf-query/issues/230))
 
 ### Features
 
-* greenfield rewrite on a promise kernel, with load() handles and opt-in behaviors ([#230](https://github.com/KATT/raf-query/issues/230)) ([e2a6f85](https://github.com/KATT/raf-query/commit/e2a6f85297992dc8a5cdd3f871a54452393ae978))
+- greenfield rewrite on a promise kernel, with load() handles and opt-in behaviors ([#230](https://github.com/KATT/raf-query/issues/230)) ([e2a6f85](https://github.com/KATT/raf-query/commit/e2a6f85297992dc8a5cdd3f871a54452393ae978))
 
 ## [0.11.1](https://github.com/KATT/raf-query/compare/0.11.0...0.11.1) (2026-10-17)
 

package/dist/client.d.mts

@@ -11,14 +11,22 @@ type FeatureFunction = (client: QueryClient, signal: AbortSignal) => void;
 export type AnyLink = LinkFunction & AnyPart;
 /** Any feature, whatever `meta` it reads. */
 export type AnyFeature = FeatureFunction & AnyPart;
-/** Time and timers, injectable so tests control them without patching globals. */
+/**
+ * Time and timers, injectable so tests control them without patching globals.
+ *
+ * @see https://raf-query.katt.dev/docs/testing#time
+ */
 export interface Clock {
   clearTimeout(handle: unknown): void;
   now(): number;
   setTimeout(callback: () => void, ms: number): unknown;
 }
 export declare const systemClock: Clock;
-/** One request, as links see it. `TMeta` is what the link declares. */
+/**
+ * One request, as links see it. `TMeta` is what the link declares.
+ *
+ * @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
+ */
 export interface Operation<TMeta extends object = object> {
   readonly client: QueryClient;
   /** The entry's data when the request started (paged queries extend it). */
@@ -40,11 +48,15 @@ export interface Operation<TMeta extends object = object> {
  * Wraps every request, like a tRPC link. Call `next(op)` to run the rest of
  * the chain; the last link is the query's own `queryFn`. `TDecl` is the
  * `meta` it reads: see {@link link}.
+ *
+ * @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
  */
 export type Link<TDecl extends Decl = Decl> = LinkFunction & Declares<TDecl>;
 /**
  * A cache-wide behavior, started when a provider mounts the client and
  * stopped by `signal`. `TDecl` is the `meta` it reads: see {@link feature}.
+ *
+ * @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
  */
 export type Feature<TDecl extends Decl = Decl> = FeatureFunction & Declares<TDecl>;
 /**
@@ -56,6 +68,8 @@ export type Feature<TDecl extends Decl = Decl> = FeatureFunction & Declares<TDec
  *   withTrace(op.meta.traceId, () => next(op)),
  * );
  * ```
+ *
+ * @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
  */
 export declare function link<TDecl extends Decl = Decl>(run: (op: Operation<MetaOfDecl<TDecl> & object>, next: (op: Operation) => Promise<unknown>) => Promise<unknown>): Link<TDecl>;
 /**
@@ -66,6 +80,8 @@ export declare function link<TDecl extends Decl = Decl>(run: (op: Operation<Meta
  * ```ts
  * const ownership = feature<{ meta: { owner?: "posts-team" | "users-team" } }>();
  * ```
+ *
+ * @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
  */
 export declare function feature<TDecl extends Decl = Decl>(setup?: FeatureFunction): Feature<TDecl>;
 export type ClientEvent = {
@@ -75,6 +91,11 @@ export type ClientEvent = {
   readonly entry: Entry;
   readonly type: "readers";
 };
+/**
+ * What `createQueryClient` takes: links, features and the cache-wide defaults.
+ *
+ * @see https://raf-query.katt.dev/docs/important-defaults#changing-the-defaults
+ */
 export interface QueryClientConfig {
   readonly clock?: Clock;
   /** Behaviors started while a provider has the client mounted. */
@@ -94,6 +115,8 @@ export interface QueryClientConfig {
  * A query cache. `TTypes` is its root's types, which factories built with
  * `bindQueryOptions<typeof makeQueryClient>()` are checked against. The bare
  * `QueryClient` type takes a client of any root.
+ *
+ * @see https://raf-query.katt.dev/docs/api-reference#the-client
  */
 export interface QueryClient<TTypes extends RootTypes = AnyRoot> {
   /** Entries changed since the last notification. */
@@ -111,8 +134,15 @@ export interface QueryClient<TTypes extends RootTypes = AnyRoot> {
   readonly clock: Clock;
   readonly config: QueryClientConfig;
   readonly isServer: boolean;
-  /** Cache events: entries added, updated, removed, or gaining and losing readers. */
-  subscribe(listener: (event: ClientEvent) => void, options?: SubscribeOptions): () => void;
+  /**
+   * Cache events: entries added, updated, removed, or gaining and losing
+   * readers. With `replay: true`, the listener first gets an `added` event
+   * for every entry the cache already holds, so a feature that keeps
+   * entries in sync starts from what's there.
+   */
+  subscribe(listener: (event: ClientEvent) => void, options?: SubscribeOptions & {
+    readonly replay?: boolean;
+  }): () => void;
 }
 /**
  * Create a query client. Behaviors are opt-in: pass `links` and `features`,
@@ -126,6 +156,8 @@ export interface QueryClient<TTypes extends RootTypes = AnyRoot> {
  *
  * Make one per request on the server (in a loader or a request-scoped
  * cache), never at module level.
+ *
+ * @see https://raf-query.katt.dev/docs/important-defaults
  */
 export declare function createQueryClient<const TLinks extends ReadonlyArray<AnyLink> = [], const TFeatures extends ReadonlyArray<AnyFeature> = []>(config?: QueryClientConfig & {
   readonly features?: TFeatures;
@@ -135,7 +167,8 @@ export declare function createQueryClient<const TLinks extends ReadonlyArray<Any
 }>;
 /**
  * Start the client's features. Providers call it while mounted; the
- * returned function stops them.
+ * returned function stops them. Mounts are counted, so features start once
+ * however many providers share the client, and stop with the last.
  */
 export declare function mount(client: QueryClient): () => void;
 //#endregion

package/dist/client.mjs

@@ -16,6 +16,8 @@ const systemClock = {
 *   withTrace(op.meta.traceId, () => next(op)),
 * );
 * ```
+*
+* @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
 */
 function link(run) {
 	return run;
@@ -29,6 +31,8 @@ const noop = () => {};
 * ```ts
 * const ownership = feature<{ meta: { owner?: "posts-team" | "users-team" } }>();
 * ```
+*
+* @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
 */
 function feature(setup = noop) {
 	return setup;
@@ -45,29 +49,56 @@ function feature(setup = noop) {
 *
 * Make one per request on the server (in a loader or a request-scoped
 * cache), never at module level.
+*
+* @see https://raf-query.katt.dev/docs/important-defaults
 */
 function createQueryClient(config = {}) {
 	const events = listeners();
+	const entries = /* @__PURE__ */ new Map();
 	return {
 		"~changed": /* @__PURE__ */ new Set(),
-		"~entries": /* @__PURE__ */ new Map(),
+		"~entries": entries,
 		"~events": events,
 		"~seq": 0,
 		"~stamps": [],
 		clock: config.clock ?? systemClock,
 		config,
 		isServer: config.isServer ?? !("window" in globalThis),
-		subscribe: (listener, options) => events.subscribe(listener, options)
+		subscribe: (listener, options) => {
+			const unsubscribe = events.subscribe(listener, options);
+			if (options?.replay && !options.signal?.aborted) for (const entry of entries.values()) listener({
+				entry,
+				type: "added"
+			});
+			return unsubscribe;
+		}
 	};
 }
+const mounted = /* @__PURE__ */ new WeakMap();
 /**
 * Start the client's features. Providers call it while mounted; the
-* returned function stops them.
+* returned function stops them. Mounts are counted, so features start once
+* however many providers share the client, and stop with the last.
 */
 function mount(client) {
-	const controller = new AbortController();
-	for (const start of client.config.features ?? []) start(client, controller.signal);
-	return () => controller.abort();
+	let current = mounted.get(client);
+	if (!current) {
+		current = {
+			controller: new AbortController(),
+			count: 0
+		};
+		mounted.set(client, current);
+		for (const start of client.config.features ?? []) start(client, current.controller.signal);
+	}
+	const shared = current;
+	shared.count += 1;
+	return () => {
+		shared.count -= 1;
+		if (shared.count === 0) {
+			mounted.delete(client);
+			shared.controller.abort();
+		}
+	};
 }
 //#endregion
 export { createQueryClient, feature, link, mount, systemClock };

package/dist/entry.d.mts

@@ -46,6 +46,11 @@ export interface Entry {
   state: EntryState;
   thenable: Thenable<unknown>;
 }
+/**
+ * Make the `AbortError` (a `DOMException`) that a `load` waiting on a removed query rejects with.
+ *
+ * @see https://raf-query.katt.dev/docs/query-cancellation#when-requests-are-aborted
+ */
 export declare function abortError(): DOMException;
 /**
  * The entry for a factory's input, created if missing, with the factory's
@@ -55,6 +60,8 @@ export declare function abortError(): DOMException;
 export declare function entryOf(client: QueryClient, factory: AnyFactory, input: unknown): Entry;
 /** Whether an invalidation newer than the entry's data covers it. */
 export declare function isInvalidated(entry: Entry): boolean;
+/** Whether the entry is a browser-only query (`ssr: false`) on a server client: nothing starts it there. */
+export declare function isBrowserOnly(entry: Entry): boolean;
 /** Whether the entry's data should be refetched before it's trusted. */
 export declare function isStale(entry: Entry): boolean;
 export interface FetchRequest {

package/dist/entry.mjs

@@ -16,6 +16,11 @@ const initialState = {
 	updatedAt: 0
 };
 const fiveMinutes = 3e5;
+/**
+* Make the `AbortError` (a `DOMException`) that a `load` waiting on a removed query rejects with.
+*
+* @see https://raf-query.katt.dev/docs/query-cancellation#when-requests-are-aborted
+*/
 function abortError() {
 	return new DOMException("The query was cancelled", "AbortError");
 }
@@ -123,6 +128,10 @@ function entryOf(client, factory, input) {
 function isInvalidated(entry) {
 	return entry.client["~stamps"].some((stamp) => stamp.at > entry.requestedAt && matches(entry, stamp));
 }
+/** Whether the entry is a browser-only query (`ssr: false`) on a server client: nothing starts it there. */
+function isBrowserOnly(entry) {
+	return entry.client.isServer && entry.options?.ssr === false;
+}
 /** Whether the entry's data should be refetched before it's trusted. */
 function isStale(entry) {
 	const state = entry.state;
@@ -206,6 +215,7 @@ function terminal(op) {
 		const options = op.options;
 		const paged = options["~run"];
 		resolve(paged ? paged(op) : options.queryFn({
+			client: op.client,
 			meta: op.meta,
 			queryKey: op.queryKey,
 			signal: op.signal
@@ -229,7 +239,7 @@ function fetchEntry(entry, request = {}) {
 	const current = entry.run;
 	if (current && !request.restart && request.direction === void 0) return current.done.promise;
 	const options = entry.options;
-	if (!options) return Promise.resolve({ ok: true });
+	if (!options || isBrowserOnly(entry)) return Promise.resolve({ ok: true });
 	current?.controller.abort();
 	const client = entry.client;
 	const run = {
@@ -263,6 +273,10 @@ function fetchEntry(entry, request = {}) {
 			pump(entry, run, result, options.stream);
 			return;
 		}
+		if (!options["~run"] && entry.requestedAt > run.startedAt) {
+			finish(entry, run, { ok: true });
+			return;
+		}
 		write(entry, result, client.clock.now(), run.startedAt);
 		finish(entry, run, { ok: true });
 	}, (error) => {
@@ -352,4 +366,4 @@ function invalidate(client, makeStamps) {
 	return Promise.all(refetches).then(() => {});
 }
 //#endregion
-export { abortError, adopt, entryForKey, entryOf, fetchEntry, invalidate, isInvalidated, isStale, remove, reset, subscribeEntry, write };
+export { abortError, adopt, entryForKey, entryOf, fetchEntry, invalidate, isBrowserOnly, isInvalidated, isStale, remove, reset, subscribeEntry, write };

package/dist/features/focus-refetch/focus-refetch.d.mts

@@ -8,6 +8,8 @@ export interface FocusRefetchMeta {
 /**
  * Refetch read, stale queries when the window regains focus, except those
  * with `meta: { refetchOnWindowFocus: false }`.
+ *
+ * @see https://raf-query.katt.dev/docs/window-focus-refetching
  */
 export declare function focusRefetch(): Feature<{
   readonly meta: FocusRefetchMeta;

package/dist/features/focus-refetch/focus-refetch.mjs

@@ -4,6 +4,8 @@ import { refetchStaleReads } from "../shared.mjs";
 /**
 * Refetch read, stale queries when the window regains focus, except those
 * with `meta: { refetchOnWindowFocus: false }`.
+*
+* @see https://raf-query.katt.dev/docs/window-focus-refetching
 */
 function focusRefetch() {
 	return feature((client, signal) => {

package/dist/features/polling/polling.d.mts

@@ -5,7 +5,11 @@ export interface PollingMeta {
   /** Refetch every `n` ms while the query is read. */
   readonly refetchInterval?: number | false;
 }
-/** Refetch read queries every `meta.refetchInterval` ms. */
+/**
+ * Refetch read queries every `meta.refetchInterval` ms.
+ *
+ * @see https://raf-query.katt.dev/docs/polling
+ */
 export declare function polling(): Feature<{
   readonly meta: PollingMeta;
 }>;

package/dist/features/polling/polling.mjs

@@ -3,7 +3,11 @@ import { isNumber } from "../../guards.mjs";
 import { fetchEntry } from "../../entry.mjs";
 import { metaOf } from "../shared.mjs";
 //#region src/features/polling/polling.ts
-/** Refetch read queries every `meta.refetchInterval` ms. */
+/**
+* Refetch read queries every `meta.refetchInterval` ms.
+*
+* @see https://raf-query.katt.dev/docs/polling
+*/
 function polling() {
 	return feature((client, signal) => {
 		const timers = /* @__PURE__ */ new Map();

package/dist/features/reconnect-refetch/reconnect-refetch.d.mts

@@ -8,6 +8,8 @@ export interface ReconnectRefetchMeta {
 /**
  * Refetch read, stale queries when the browser comes back online, except
  * those with `meta: { refetchOnReconnect: false }`.
+ *
+ * @see https://raf-query.katt.dev/docs/testing#focus-and-the-network
  */
 export declare function reconnectRefetch(): Feature<{
   readonly meta: ReconnectRefetchMeta;

package/dist/features/reconnect-refetch/reconnect-refetch.mjs

@@ -4,6 +4,8 @@ import { refetchStaleReads } from "../shared.mjs";
 /**
 * Refetch read, stale queries when the browser comes back online, except
 * those with `meta: { refetchOnReconnect: false }`.
+*
+* @see https://raf-query.katt.dev/docs/testing#focus-and-the-network
 */
 function reconnectRefetch() {
 	return feature((client, signal) => {

package/dist/hydration/hydration.d.mts

@@ -2,7 +2,11 @@ import { QueryKey } from "../keys/keys.mjs";
 import { Entry } from "../entry.mjs";
 import { QueryClient } from "../client.mjs";
 //#region src/hydration/hydration.d.ts
-/** What a dehydrated pending entry's promise resolves to. */
+/**
+ * What a dehydrated pending entry's promise resolves to.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
+ */
 export interface DehydratedResult {
   readonly data?: unknown;
   /** When the sender got the result (ms since epoch). */
@@ -12,6 +16,8 @@ export interface DehydratedResult {
  * One cache entry in transit. Settled entries carry `data` and
  * `updatedAt > 0`; entries still loading carry their request's `promise`,
  * so the receiver resumes it instead of fetching again.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
  */
 export interface DehydratedEntry {
   readonly data?: unknown;
@@ -20,9 +26,19 @@ export interface DehydratedEntry {
   /** When the data was fetched; `0` while pending. */
   readonly updatedAt: number;
 }
+/**
+ * A cache, serialized by {@link dehydrate} for {@link hydrate}.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
+ */
 export interface DehydratedState {
   readonly entries: ReadonlyArray<DehydratedEntry>;
 }
+/**
+ * Options for {@link dehydrate} and {@link dehydrateStream}.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
+ */
 export interface DehydrateOptions {
   /**
    * Which entries to send. Default: entries with data or a request in
@@ -40,16 +56,31 @@ export interface DehydrateOptions {
 /**
  * What a streamed pending entry rejects with when its server request threw:
  * the browser learns which query failed, not why.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration#errors
  */
 export declare class RedactedError extends Error {
   readonly name = "RedactedError";
   readonly hash: string;
   constructor(hash: string);
 }
-/** The default filter: entries with data or a request in flight. */
+/**
+ * The default filter: entries with data or a request in flight.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
+ */
 export declare function canDehydrate(entry: Entry): boolean;
-/** Snapshot the client's entries for transfer. */
+/**
+ * Snapshot the client's entries for transfer.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
+ */
 export declare function dehydrate(client: QueryClient, options?: DehydrateOptions): DehydratedState;
+/**
+ * What {@link dehydrateStream} returns: the entries to send first, then their updates.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
+ */
 export interface DehydratedStream {
   /** Stop: send what changed, then end `updates`. */
   close(): void;
@@ -61,6 +92,8 @@ export interface DehydratedStream {
 /**
  * The cache now, then entries as they start, until `close()`. Snapshots and
  * subscribes in one synchronous step, so no change falls between the two.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
  */
 export declare function dehydrateStream(client: QueryClient, options?: DehydrateOptions): DehydratedStream;
 /**
@@ -68,6 +101,8 @@ export declare function dehydrateStream(client: QueryClient, options?: Dehydrate
  * data. A pending entry the client has nothing for resumes the sender's
  * request; one that has data or a request of its own waits for the
  * sender's, takes it if newer, and revalidates if the sender's failed.
+ *
+ * @see https://raf-query.katt.dev/docs/ssr-and-hydration
  */
 export declare function hydrate(client: QueryClient, state: DehydratedState): void;
 //#endregion

package/dist/hydration/hydration.mjs

@@ -3,6 +3,8 @@ import { adopt, entryForKey, fetchEntry, isStale, write } from "../entry.mjs";
 /**
 * What a streamed pending entry rejects with when its server request threw:
 * the browser learns which query failed, not why.
+*
+* @see https://raf-query.katt.dev/docs/ssr-and-hydration#errors
 */
 var RedactedError = class extends Error {
 	name = "RedactedError";
@@ -12,7 +14,11 @@ var RedactedError = class extends Error {
 		this.hash = hash;
 	}
 };
-/** The default filter: entries with data or a request in flight. */
+/**
+* The default filter: entries with data or a request in flight.
+*
+* @see https://raf-query.katt.dev/docs/ssr-and-hydration
+*/
 function canDehydrate(entry) {
 	const state = entry.state;
 	return state.hasData || state.isFetching;
@@ -54,13 +60,19 @@ function dehydrateEntries(entries, options) {
 	}
 	return { entries: dehydrated };
 }
-/** Snapshot the client's entries for transfer. */
+/**
+* Snapshot the client's entries for transfer.
+*
+* @see https://raf-query.katt.dev/docs/ssr-and-hydration
+*/
 function dehydrate(client, options = {}) {
 	return dehydrateEntries(client["~entries"].values(), options);
 }
 /**
 * The cache now, then entries as they start, until `close()`. Snapshots and
 * subscribes in one synchronous step, so no change falls between the two.
+*
+* @see https://raf-query.katt.dev/docs/ssr-and-hydration
 */
 function dehydrateStream(client, options = {}) {
 	const send = {
@@ -112,6 +124,8 @@ function takeNewer(entry, result) {
 * data. A pending entry the client has nothing for resumes the sender's
 * request; one that has data or a request of its own waits for the
 * sender's, takes it if newer, and revalidates if the sender's failed.
+*
+* @see https://raf-query.katt.dev/docs/ssr-and-hydration
 */
 function hydrate(client, state) {
 	for (const sent of state.entries) {

package/dist/index.d.mts

@@ -10,9 +10,10 @@ import { reconnectRefetch } from "./features/reconnect-refetch/reconnect-refetch
 import { polling } from "./features/polling/polling.mjs";
 import { DehydrateOptions, DehydratedEntry, DehydratedResult, DehydratedState, DehydratedStream, RedactedError, canDehydrate, dehydrate, dehydrateStream, hydrate } from "./hydration/hydration.mjs";
 import { InfiniteData, InfiniteQueryFunctionContext, InfiniteQueryOptions, InfiniteQueryOptionsBuilder, bindInfiniteQueryOptions, infiniteQueryOptions } from "./infinite/infinite.mjs";
+import { ClientFor, PartialInput, getData, invalidateAll, invalidateMany, invalidateOne, isFetching, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, setData } from "./verbs.mjs";
+import { PageControls, PageDirection, PageState, fetchNextPage, fetchPreviousPage, hasNextPage, hasPreviousPage } from "./infinite/paging.mjs";
 import { RetryOptions, retry } from "./links/retry/retry.mjs";
 import { QueryTimeoutError, timeout } from "./links/timeout/timeout.mjs";
 import { LoadEntry, LoadEntryOptions, Loaded, QueryHandle, load, prefetch, revalidate, skipToken, swr, waterfallHandle } from "./load.mjs";
 import { Recommended, recommended } from "./presets.mjs";
-import { ClientFor, PartialInput, getData, invalidateAll, invalidateMany, invalidateOne, isFetching, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, setData } from "./verbs.mjs";
-export { type ClientFor, type Clock, type DataOf, type DehydrateOptions, type DehydratedEntry, type DehydratedResult, type DehydratedState, type DehydratedStream, type Feature, type Group, type InfiniteData, type InfiniteQueryFactory, type InfiniteQueryFunctionContext, type InfiniteQueryOptions, type InfiniteQueryOptionsBuilder, type InputOf, type Link, type LoadEntry, type LoadEntryOptions, type Loaded, type Operation, type PartialInput, type QueryClient, type QueryClientConfig, type QueryFactory, type QueryFunctionContext, type QueryHandle, type QueryInfo, type QueryKey, type QueryMeta, type QueryOptions, type QueryOptionsBuilder, QueryTimeoutError, type Recommended, RedactedError, type RetryOptions, type SingleQueryFactory, type StreamOptions, type Target, type Thenable, abortError, bindInfiniteQueryOptions, bindQueryOptions, canDehydrate, createQueryClient, dehydrate, dehydrateStream, feature, focusRefetch, getData, group, hydrate, infiniteQueryOptions, invalidateAll, invalidateMany, invalidateOne, isFetching, link, load, polling, prefetch, queryOptions, recommended, reconnectRefetch, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, retry, revalidate, setData, skipToken, swr, timeout, waterfallHandle };
+export { type ClientFor, type Clock, type DataOf, type DehydrateOptions, type DehydratedEntry, type DehydratedResult, type DehydratedState, type DehydratedStream, type Feature, type Group, type InfiniteData, type InfiniteQueryFactory, type InfiniteQueryFunctionContext, type InfiniteQueryOptions, type InfiniteQueryOptionsBuilder, type InputOf, type Link, type LoadEntry, type LoadEntryOptions, type Loaded, type Operation, type PageControls, type PageDirection, type PageState, type PartialInput, type QueryClient, type QueryClientConfig, type QueryFactory, type QueryFunctionContext, type QueryHandle, type QueryInfo, type QueryKey, type QueryMeta, type QueryOptions, type QueryOptionsBuilder, QueryTimeoutError, type Recommended, RedactedError, type RetryOptions, type SingleQueryFactory, type StreamOptions, type Target, type Thenable, abortError, bindInfiniteQueryOptions, bindQueryOptions, canDehydrate, createQueryClient, dehydrate, dehydrateStream, feature, fetchNextPage, fetchPreviousPage, focusRefetch, getData, group, hasNextPage, hasPreviousPage, hydrate, infiniteQueryOptions, invalidateAll, invalidateMany, invalidateOne, isFetching, link, load, polling, prefetch, queryOptions, recommended, reconnectRefetch, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, retry, revalidate, setData, skipToken, swr, timeout, waterfallHandle };

package/dist/index.mjs

@@ -7,9 +7,10 @@ import { reconnectRefetch } from "./features/reconnect-refetch/reconnect-refetch
 import { polling } from "./features/polling/polling.mjs";
 import { RedactedError, canDehydrate, dehydrate, dehydrateStream, hydrate } from "./hydration/hydration.mjs";
 import { bindInfiniteQueryOptions, infiniteQueryOptions } from "./infinite/infinite.mjs";
+import { fetchNextPage, fetchPreviousPage, hasNextPage, hasPreviousPage } from "./infinite/paging.mjs";
 import { retry } from "./links/retry/retry.mjs";
 import { QueryTimeoutError, timeout } from "./links/timeout/timeout.mjs";
 import { load, prefetch, revalidate, skipToken, swr, waterfallHandle } from "./load.mjs";
 import { recommended } from "./presets.mjs";
 import { getData, invalidateAll, invalidateMany, invalidateOne, isFetching, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, setData } from "./verbs.mjs";
-export { QueryTimeoutError, RedactedError, abortError, bindInfiniteQueryOptions, bindQueryOptions, canDehydrate, createQueryClient, dehydrate, dehydrateStream, feature, focusRefetch, getData, group, hydrate, infiniteQueryOptions, invalidateAll, invalidateMany, invalidateOne, isFetching, link, load, polling, prefetch, queryOptions, recommended, reconnectRefetch, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, retry, revalidate, setData, skipToken, swr, timeout, waterfallHandle };
+export { QueryTimeoutError, RedactedError, abortError, bindInfiniteQueryOptions, bindQueryOptions, canDehydrate, createQueryClient, dehydrate, dehydrateStream, feature, fetchNextPage, fetchPreviousPage, focusRefetch, getData, group, hasNextPage, hasPreviousPage, hydrate, infiniteQueryOptions, invalidateAll, invalidateMany, invalidateOne, isFetching, link, load, polling, prefetch, queryOptions, recommended, reconnectRefetch, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, retry, revalidate, setData, skipToken, swr, timeout, waterfallHandle };