@raf-query/core 0.13.1 → 0.14.0

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

@@ -1,16 +1,16 @@
-import { feature } from "../../client.mjs";
+import { part } from "../../client.mjs";
 import { refetchStaleReads } from "../shared.mjs";
 //#region src/features/reconnect-refetch/reconnect-refetch.ts
 /**
 * Refetch read, stale queries when the browser comes back online, except
-* those with `meta: { refetchOnReconnect: false }`.
+* those with `refetchOnReconnect: false`.
 *
 * @see https://raf-query.katt.dev/docs/testing#focus-and-the-network
 */
 function reconnectRefetch() {
-	return feature((client, signal) => {
+	return part({ setup: (client, signal) => {
 		window.addEventListener("online", () => refetchStaleReads(client, "refetchOnReconnect"), { signal });
-	});
+	} });
 }
 //#endregion
 export { reconnectRefetch };

package/dist/features/shared.mjs

@@ -1,13 +1,15 @@
 import { isObject } from "../guards.mjs";
 import { fetchEntry, isStale } from "../entry.mjs";
 //#region src/features/shared.ts
-function metaOf(entry, field) {
-	const meta = entry.options?.meta;
-	if (!isObject(meta) || !(field in meta)) return;
-	return meta[field];
+/** An option a part declares, for the entry: the query's, or else the client's default. */
+function optionOf(entry, name) {
+	for (const options of [entry.options, entry.client.config.defaults]) if (isObject(options) && name in options) {
+		const fields = options;
+		if (fields[name] !== void 0) return fields[name];
+	}
 }
 function refetchStaleReads(client, optOut) {
-	for (const entry of client["~entries"].values()) if (entry.readers.size > 0 && isStale(entry) && metaOf(entry, optOut) !== false) fetchEntry(entry);
+	for (const entry of client["~entries"].values()) if (entry.readers.size > 0 && isStale(entry) && optionOf(entry, optOut) !== false) fetchEntry(entry);
 }
 //#endregion
-export { metaOf, refetchStaleReads };
+export { optionOf, refetchStaleReads };

package/dist/index.d.mts

@@ -1,19 +1,19 @@
 import { Group, QueryKey, group } from "./keys/keys.mjs";
-import { QueryMeta } from "./root.mjs";
 import { QueryInfo, Target } from "./keys/targets.mjs";
-import { DataOf, InfiniteQueryFactory, InputOf, QueryFactory, QueryFunctionContext, QueryOptions, QueryOptionsBuilder, SingleQueryFactory, StreamOptions, bindQueryOptions, queryOptions } from "./options.mjs";
+import { Optional, RootOf } from "./root.mjs";
+import { CoreOptions, DataOf, InfiniteQueryFactory, InputOf, OptionsOf, QueryFactory, QueryFunctionContext, QueryOptions, QueryOptionsBuilder, SingleQueryFactory, StreamOptions, bindQueryOptions, queryOptions } from "./options.mjs";
 import { Thenable } from "./thenable.mjs";
 import { abortError } from "./entry.mjs";
-import { Clock, Feature, Link, Operation, QueryClient, QueryClientConfig, createQueryClient, feature, link } from "./client.mjs";
-import { focusRefetch } from "./features/focus-refetch/focus-refetch.mjs";
-import { reconnectRefetch } from "./features/reconnect-refetch/reconnect-refetch.mjs";
-import { polling } from "./features/polling/polling.mjs";
+import { Clock, Operation, Part, QueryClient, QueryClientConfig, createQueryClient, part } from "./client.mjs";
+import { FocusRefetch, focusRefetch } from "./features/focus-refetch/focus-refetch.mjs";
+import { ReconnectRefetch, reconnectRefetch } from "./features/reconnect-refetch/reconnect-refetch.mjs";
+import { Polling, 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 { Retry, 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";
-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 };
+export { type ClientFor, type Clock, type CoreOptions, type DataOf, type DehydrateOptions, type DehydratedEntry, type DehydratedResult, type DehydratedState, type DehydratedStream, type FocusRefetch, type Group, type InfiniteData, type InfiniteQueryFactory, type InfiniteQueryFunctionContext, type InfiniteQueryOptions, type InfiniteQueryOptionsBuilder, type InputOf, type LoadEntry, type LoadEntryOptions, type Loaded, type Operation, type Optional, type OptionsOf, type PageControls, type PageDirection, type PageState, type Part, type PartialInput, type Polling, type QueryClient, type QueryClientConfig, type QueryFactory, type QueryFunctionContext, type QueryHandle, type QueryInfo, type QueryKey, type QueryOptions, type QueryOptionsBuilder, QueryTimeoutError, type Recommended, type ReconnectRefetch, RedactedError, type Retry, type RetryOptions, type RootOf, type SingleQueryFactory, type StreamOptions, type Target, type Thenable, abortError, bindInfiniteQueryOptions, bindQueryOptions, canDehydrate, createQueryClient, dehydrate, dehydrateStream, fetchNextPage, fetchPreviousPage, focusRefetch, getData, group, hasNextPage, hasPreviousPage, hydrate, infiniteQueryOptions, invalidateAll, invalidateMany, invalidateOne, isFetching, load, part, polling, prefetch, queryOptions, recommended, reconnectRefetch, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, retry, revalidate, setData, skipToken, swr, timeout, waterfallHandle };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { createQueryClient, feature, link } from "./client.mjs";
+import { createQueryClient, part } from "./client.mjs";
 import { group } from "./keys/keys.mjs";
 import { bindQueryOptions, queryOptions } from "./options.mjs";
 import { abortError } from "./entry.mjs";
@@ -13,4 +13,4 @@ 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, 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 };
+export { QueryTimeoutError, RedactedError, abortError, bindInfiniteQueryOptions, bindQueryOptions, canDehydrate, createQueryClient, dehydrate, dehydrateStream, fetchNextPage, fetchPreviousPage, focusRefetch, getData, group, hasNextPage, hasPreviousPage, hydrate, infiniteQueryOptions, invalidateAll, invalidateMany, invalidateOne, isFetching, load, part, polling, prefetch, queryOptions, recommended, reconnectRefetch, removeAll, removeMany, removeOne, resetAll, resetMany, resetOne, retry, revalidate, setData, skipToken, swr, timeout, waterfallHandle };

package/dist/infinite/infinite.d.mts

@@ -1,5 +1,5 @@
 import { QueryKey } from "../keys/keys.mjs";
-import { DefaultTypes, RootOf, RootTypes } from "../root.mjs";
+import { NoParts, RootOf, RootTypes, SetsOf } from "../root.mjs";
 import { BaseOptions, FromQueryFn, QueryFunctionContext, QueryOptions } from "../options.mjs";
 import { Operation } from "../client.mjs";
 //#region src/infinite/infinite.d.ts
@@ -17,12 +17,12 @@ export interface InfiniteData<TPage, TParam = unknown> {
  *
  * @see https://raf-query.katt.dev/docs/infinite-queries
  */
-export interface InfiniteQueryFunctionContext<TKey extends QueryKey, TParam> extends QueryFunctionContext<TKey> {
+export type InfiniteQueryFunctionContext<TKey extends QueryKey, TParam, TTypes extends RootTypes = NoParts> = QueryFunctionContext<TKey, TTypes> & {
   readonly direction: "backward" | "forward";
   readonly pageParam: TParam;
-}
+};
 type PageParamFn<TPage, TParam> = (page: TPage, pages: ReadonlyArray<TPage>, pageParam: TParam) => TParam | null | undefined;
-interface InfiniteOptions<TKey extends QueryKey, TPage, TParam, TData, TTypes extends RootTypes = RootTypes> extends BaseOptions<TKey, TTypes> {
+interface InfiniteOptions<TKey extends QueryKey, TPage, TParam, TData> extends BaseOptions<TKey> {
   readonly getNextPageParam: PageParamFn<TPage, TParam>;
   readonly getPreviousPageParam?: PageParamFn<TPage, TParam>;
   readonly initialPageParam: TParam;
@@ -45,17 +45,18 @@ interface InfiniteOptions<TKey extends QueryKey, TPage, TParam, TData, TTypes ex
  *
  * @see https://raf-query.katt.dev/docs/infinite-queries
  */
-export type InfiniteQueryOptions<TKey extends QueryKey = QueryKey, TPage = unknown, TParam = unknown, TData = InfiniteData<TPage, TParam>, TTypes extends RootTypes = RootTypes> = QueryOptions<TKey, InfiniteData<TPage, TParam>, TData, TTypes> & Pick<InfiniteOptions<TKey, TPage, TParam, TData, TTypes>, "getNextPageParam" | "getPreviousPageParam" | "initialPageParam" | "maxPages"> & {
+export type InfiniteQueryOptions<TKey extends QueryKey = QueryKey, TPage = unknown, TParam = unknown, TData = InfiniteData<TPage, TParam>, TTypes extends RootTypes = RootTypes> = QueryOptions<TKey, InfiniteData<TPage, TParam>, TData, TTypes> & Pick<InfiniteOptions<TKey, TPage, TParam, TData>, "getNextPageParam" | "getPreviousPageParam" | "initialPageParam" | "maxPages"> & {
   readonly "~run": (op: Operation) => Promise<unknown>;
 };
 /**
- * `infiniteQueryOptions`, with `meta` checked against the root `TTypes`.
+ * `infiniteQueryOptions` for a root: `TTypes` is what the factories it
+ * builds need of a client, and `TSets` the options they can set.
  *
- * @see https://raf-query.katt.dev/docs/links-and-features#typing-meta-by-its-root
+ * @see https://raf-query.katt.dev/docs/links-and-features#typing-options-by-the-client
  */
-export interface InfiniteQueryOptionsBuilder<TTypes extends RootTypes> {
-  <const TKey extends QueryKey, TPage, TParam, TData = InfiniteData<TPage, TParam>>(options: InfiniteOptions<TKey, FromQueryFn<TPage>, TParam, TData, TTypes> & {
-    readonly queryFn: (context: InfiniteQueryFunctionContext<TKey, TParam>) => PromiseLike<TPage> | TPage;
+export interface InfiniteQueryOptionsBuilder<TTypes extends RootTypes, TSets extends RootTypes = TTypes> {
+  <const TKey extends QueryKey, TPage, TParam, TData = InfiniteData<TPage, TParam>>(options: InfiniteOptions<TKey, FromQueryFn<TPage>, TParam, TData> & Partial<TSets["options"]> & {
+    readonly queryFn: (context: InfiniteQueryFunctionContext<TKey, TParam, TTypes>) => PromiseLike<TPage> | TPage;
   }): InfiniteQueryOptions<TKey, TPage, TParam, TData, TTypes>;
 }
 /**
@@ -72,12 +73,13 @@ export interface InfiniteQueryOptionsBuilder<TTypes extends RootTypes> {
  *   });
  * ```
  *
- * Its `meta` is any record. To check `meta` against a client's links and
- * features, use the builder {@link bindInfiniteQueryOptions} returns.
+ * It takes the core's options only. For the options and the `queryFn`
+ * context a client's parts declare, use the builder
+ * {@link bindInfiniteQueryOptions} returns.
  *
  * @see https://raf-query.katt.dev/docs/infinite-queries
  */
-export declare const infiniteQueryOptions: InfiniteQueryOptionsBuilder<DefaultTypes>;
+export declare const infiniteQueryOptions: InfiniteQueryOptionsBuilder<NoParts>;
 /**
  * `infiniteQueryOptions` bound to a root, like `bindQueryOptions`. Bind it
  * next to `queryOptions`, in apps that page:
@@ -87,7 +89,7 @@ export declare const infiniteQueryOptions: InfiniteQueryOptionsBuilder<DefaultTy
  * export const infiniteQueryOptions = bindInfiniteQueryOptions<typeof makeQueryClient>();
  * ```
  *
- * @see https://raf-query.katt.dev/docs/links-and-features#typing-meta-by-its-root
+ * @see https://raf-query.katt.dev/docs/links-and-features#typing-options-by-the-client
  */
-export declare function bindInfiniteQueryOptions<T>(): InfiniteQueryOptionsBuilder<RootOf<T>>;
+export declare function bindInfiniteQueryOptions<T>(): InfiniteQueryOptionsBuilder<RootOf<T>, SetsOf<T>>;
 //#endregion

package/dist/infinite/infinite.mjs

@@ -14,8 +14,9 @@ import { hashKey } from "../keys/keys.mjs";
 *   });
 * ```
 *
-* Its `meta` is any record. To check `meta` against a client's links and
-* features, use the builder {@link bindInfiniteQueryOptions} returns.
+* It takes the core's options only. For the options and the `queryFn`
+* context a client's parts declare, use the builder
+* {@link bindInfiniteQueryOptions} returns.
 *
 * @see https://raf-query.katt.dev/docs/infinite-queries
 */
@@ -33,7 +34,7 @@ const infiniteQueryOptions = (options) => ({
 * export const infiniteQueryOptions = bindInfiniteQueryOptions<typeof makeQueryClient>();
 * ```
 *
-* @see https://raf-query.katt.dev/docs/links-and-features#typing-meta-by-its-root
+* @see https://raf-query.katt.dev/docs/links-and-features#typing-options-by-the-client
 */
 function bindInfiniteQueryOptions() {
 	return infiniteQueryOptions;
@@ -65,9 +66,9 @@ function pageFor(data, pageParam) {
 }
 async function runPages(op, source) {
 	const fetchPage = (pageParam, direction) => Promise.resolve(source.queryFn({
+		...op.client.context,
 		client: op.client,
 		direction,
-		meta: op.meta,
 		pageParam,
 		queryKey: op.queryKey,
 		signal: op.signal

package/dist/internal.d.mts

@@ -1,13 +1,9 @@
 import { AnyFactory, hashKey } from "./keys/keys.mjs";
-import { Decl, DefaultTypes, MetaOf, RootOf, RootTypes } from "./root.mjs";
 import { AnyTarget } from "./keys/targets.mjs";
+import { Decl, NoParts, Root, RootOf, RootOfParts, RootTypes, SetsOf } from "./root.mjs";
 import { fulfilled, mapThenable, pending, rejected } from "./thenable.mjs";
 import { Entry, EntryState, entryOf, fetchEntry, isBrowserOnly, isInvalidated, isStale, remove, reset, subscribeEntry } from "./entry.mjs";
-import { AnyFeature, AnyLink, ClientEvent, mount, systemClock } from "./client.mjs";
-import { FocusRefetchMeta } from "./features/focus-refetch/focus-refetch.mjs";
-import { ReconnectRefetchMeta } from "./features/reconnect-refetch/reconnect-refetch.mjs";
-import { PollingMeta } from "./features/polling/polling.mjs";
+import { AnyPart, ClientEvent, mount, systemClock } from "./client.mjs";
 import { fetchPage, pageState } from "./infinite/paging.mjs";
-import { RetryMeta } from "./links/retry/retry.mjs";
 import { LoadRecord, isWaterfallHandle, loadsOf, readData, startIfStale } from "./load.mjs";
-export { type AnyFactory, type AnyFeature, type AnyLink, type AnyTarget, type ClientEvent, type Decl, type DefaultTypes, type Entry, type EntryState, type FocusRefetchMeta, type LoadRecord, type MetaOf, type PollingMeta, type ReconnectRefetchMeta, type RetryMeta, type RootOf, type RootTypes, entryOf, fetchEntry, fetchPage, fulfilled, hashKey, isBrowserOnly, isInvalidated, isStale, isWaterfallHandle, loadsOf, mapThenable, mount, pageState, pending, readData, rejected, remove, reset, startIfStale, subscribeEntry, systemClock };
+export { type AnyFactory, type AnyPart, type AnyTarget, type ClientEvent, type Decl, type Entry, type EntryState, type LoadRecord, type NoParts, type Root, type RootOf, type RootOfParts, type RootTypes, type SetsOf, entryOf, fetchEntry, fetchPage, fulfilled, hashKey, isBrowserOnly, isInvalidated, isStale, isWaterfallHandle, loadsOf, mapThenable, mount, pageState, pending, readData, rejected, remove, reset, startIfStale, subscribeEntry, systemClock };

package/dist/keys/targets.d.mts

@@ -1,17 +1,16 @@
 import { AnyFactory, Group, QueryKey } from "./keys.mjs";
-import { QueryMeta } from "../root.mjs";
 //#region src/keys/targets.d.ts
 /**
  * What a target's `where` sees of a query.
  *
  * @see https://raf-query.katt.dev/docs/query-invalidation#matching-with-where
  */
-export interface QueryInfo<TMeta = QueryMeta> {
+export interface QueryInfo<TOptions = object> {
   /** The query's data, before `select`; `undefined` without data. */
   readonly data: unknown;
   readonly input: unknown;
-  /** The `meta` its factory gave it. An entry only hydrated has `{}` until it's read. */
-  readonly meta: TMeta;
+  /** The options its factory gave it. An entry only hydrated has `{}` until it's read. */
+  readonly options: TOptions;
   readonly queryKey: QueryKey;
 }
 /**
@@ -19,16 +18,16 @@ export interface QueryInfo<TMeta = QueryMeta> {
  * parameter the verb was called with.
  *
  * ```ts
- * const ownedBy: Target<AppMeta, Team> = { where: (query, team) => query.meta.owner === team };
+ * const ownedBy: Target<RootOf<Ownership>["options"], Team> = { where: (query, team) => query.options.owner === team };
  * await invalidateMany(client, ownedBy, "editorial");
  * ```
  *
  * @see https://raf-query.katt.dev/docs/query-invalidation#targets
  */
-export interface Target<TMeta = QueryMeta, TParam = never> {
-  readonly where: (query: QueryInfo<TMeta>, param: TParam) => boolean;
+export interface Target<TOptions = object, TParam = never> {
+  readonly where: (query: QueryInfo<TOptions>, param: TParam) => boolean;
 }
-/** A target of any meta and parameter. */
+/** A target of any options and parameter. */
 export interface AnyTarget {
   readonly where: (query: never, param: never) => boolean;
 }

package/dist/keys/targets.mjs

@@ -12,14 +12,15 @@ import { isPlainRecord } from "./keys.mjs";
 *   path, `drafts("byId", input)` is `["posts", "drafts", "byId", input]`.
 *   It matches every key that starts with its path, whoever built the key,
 *   so it covers its subgroups and their queries.
-* - Any object with `where(query, param)`, typed by the client's root
-*   `meta`: predicates over a query's key, input, `meta` or data. Tags
-*   are one, written in user code over a `meta.tags` a feature declares.
+* - Any object with `where(query, param)`, typed by the options the
+*   client's parts declare: predicates over a query's key, input, options
+*   or data. Tags are one, written in user code over a `tags` option a
+*   part declares.
 *
 * Invalidation records a stamp per target. An entry is invalidated when a
 * matching stamp is newer than the request its data came from. Entries with
 * readers refetch at once; the rest are checked when they are next read,
-* which always goes through their factory, so `where` sees their `meta`.
+* which always goes through their factory, so `where` sees their options.
 *
 * An entry that was only hydrated has no factory or input until it's read.
 * A factory target covers it from that first read: invalidation through its
@@ -64,7 +65,7 @@ function infoOf(entry) {
 	return {
 		data: entry.state.data,
 		input: entry.input,
-		meta: entry.options?.meta ?? {},
+		options: entry.options ?? {},
 		queryKey: entry.key
 	};
 }

package/dist/links/retry/retry.d.mts

@@ -1,4 +1,4 @@
-import { Link } from "../../client.mjs";
+import { Part } from "../../client.mjs";
 //#region src/links/retry/retry.d.ts
 /**
  * Options for {@link retry}.
@@ -6,28 +6,32 @@ import { Link } from "../../client.mjs";
  * @see https://raf-query.katt.dev/docs/retries#options
  */
 export interface RetryOptions {
-  /** Retries after the first attempt. A query's `meta.retry` wins. Default 3. */
+  /** Retries after the first attempt. A query's `retry`, or the client's default for it, wins. Default 3. */
   readonly attempts?: number;
   /** Wait before retry `n` (0-based), in ms. Default: doubling from 1 s, at most 30 s. */
   readonly delay?: (attempt: number) => number;
   /** Whether an error is worth retrying. Default: every error but a thrown `Response`. */
   readonly when?: (error: unknown) => boolean;
 }
-/** What `retry()` reads from a query's `meta`. */
-export interface RetryMeta {
-  /** Attempts for this query, or `false`. */
-  readonly retry?: number | false;
+/**
+ * What `retry()` declares.
+ *
+ * @see https://raf-query.katt.dev/docs/retries
+ */
+export interface Retry {
+  readonly options: {
+    /** Attempts for this query, or `false`. */
+    readonly retry?: number | false;
+  };
 }
 /**
  * Retry failed requests. Thrown `Response`s (router redirects and
  * not-founds) and cancelled requests aren't retried,
  * server clients never retry, and a browser that is offline
  * waits until it's back online before retrying. A query sets its own
- * attempts with `meta: { retry }`.
+ * attempts with `retry`.
  *
  * @see https://raf-query.katt.dev/docs/retries
  */
-export declare function retry(options?: RetryOptions): Link<{
-  readonly meta: RetryMeta;
-}>;
+export declare function retry(options?: RetryOptions): Part<Retry>;
 //#endregion

package/dist/links/retry/retry.mjs

@@ -1,4 +1,4 @@
-import { link } from "../../client.mjs";
+import { part } from "../../client.mjs";
 import { isResponse } from "../../guards.mjs";
 //#region src/links/retry/retry.ts
 function wait(clock, ms, signal) {
@@ -31,13 +31,13 @@ const notThrownResponse = (error) => !isResponse(error);
 * not-founds) and cancelled requests aren't retried,
 * server clients never retry, and a browser that is offline
 * waits until it's back online before retrying. A query sets its own
-* attempts with `meta: { retry }`.
+* attempts with `retry`.
 *
 * @see https://raf-query.katt.dev/docs/retries
 */
 function retry(options = {}) {
-	return link(async (op, next) => {
-		const configured = op.meta.retry;
+	return part({ link: async (op, next) => {
+		const configured = op.options.retry;
 		const attempts = configured === false ? 0 : configured ?? options.attempts ?? 3;
 		if (op.client.isServer || attempts === 0) return next(op);
 		for (let attempt = 0;; attempt++) try {
@@ -47,7 +47,7 @@ function retry(options = {}) {
 			await wait(op.client.clock, (options.delay ?? defaultDelay)(attempt), op.signal);
 			await whenOnline(op.signal);
 		}
-	});
+	} });
 }
 //#endregion
 export { retry };

package/dist/links/timeout/timeout.d.mts

@@ -1,4 +1,4 @@
-import { Link } from "../../client.mjs";
+import { Part } from "../../client.mjs";
 //#region src/links/timeout/timeout.d.ts
 /**
  * What a request that took too long fails with.
@@ -13,5 +13,5 @@ export declare class QueryTimeoutError extends Error {
  *
  * @see https://raf-query.katt.dev/docs/retries#timeouts
  */
-export declare function timeout(ms: number): Link;
+export declare function timeout(ms: number): Part;
 //#endregion

package/dist/links/timeout/timeout.mjs

@@ -1,3 +1,4 @@
+import { part } from "../../client.mjs";
 //#region src/links/timeout/timeout.ts
 /**
 * What a request that took too long fails with.
@@ -13,7 +14,7 @@ var QueryTimeoutError = class extends Error {
 * @see https://raf-query.katt.dev/docs/retries#timeouts
 */
 function timeout(ms) {
-	return (op, next) => {
+	return part({ link: (op, next) => {
 		const controller = new AbortController();
 		const signal = AbortSignal.any([op.signal, controller.signal]);
 		return new Promise((resolve, reject) => {
@@ -29,7 +30,7 @@ function timeout(ms) {
 				op.client.clock.clearTimeout(handle);
 			});
 		});
-	};
+	} });
 }
 //#endregion
 export { QueryTimeoutError, timeout };

package/dist/load.d.mts

@@ -1,4 +1,5 @@
-import { DataOf, InputArgs, InputOf, KeyOf, QueryFactory } from "./options.mjs";
+import { RootTypes } from "./root.mjs";
+import { DataOf, InputArgs, InputOf, KeyOf, QueryFactory, RootOfFactory } from "./options.mjs";
 import { Entry } from "./entry.mjs";
 import { QueryClient } from "./client.mjs";
 //#region src/load.d.ts
@@ -84,6 +85,12 @@ type LoadEntries = Record<string, LoadEntry | typeof skipToken>;
 type HandleOf<TEntry> = TEntry extends LoadEntry ? QueryHandle<TEntry["factory"]> : undefined;
 type DataOfEntry<TEntry> = TEntry extends LoadEntry ? DataOf<TEntry["factory"]> : never;
 type LoadedData<TEntries extends LoadEntries> = { [TName in keyof TEntries as TEntries[TName] extends LoadEntry<QueryFactory, "revalidate" | "swr"> ? TName : never]: DataOfEntry<TEntries[TName]>; };
+/** In an error: the parts an entry's factory needs, which the client passed to `load` lacks. */
+interface ClientLacksParts<TTypes extends RootTypes> {
+  readonly "~the client lacks parts this entry's factory needs": TTypes;
+}
+/** An entry, if the client has the parts its factory needs; else what it needs. */
+type EntryFor<TTypes extends RootTypes, TEntry> = TEntry extends LoadEntry<infer TFactory> ? [TTypes] extends [RootOfFactory<TFactory>] ? TEntry : ClientLacksParts<RootOfFactory<TFactory>> : TEntry;
 /**
  * What `load` resolves to: a handle per entry (`undefined` for `skipToken`),
  * and the data of `swr` and `revalidate` entries.
@@ -124,7 +131,7 @@ export declare function startIfStale(entry: Entry): void;
  *
  * @see https://raf-query.katt.dev/docs/starting-queries
  */
-export declare function load<const TEntries extends LoadEntries>(client: QueryClient, entries: TEntries): Promise<Loaded<TEntries>>;
+export declare function load<TTypes extends RootTypes, const TEntries extends LoadEntries>(client: QueryClient<TTypes>, entries: TEntries & { readonly [TName in keyof TEntries]: EntryFor<TTypes, TEntries[TName]>; }): Promise<Loaded<TEntries>>;
 /** Whether a handle came from `waterfallHandle()`: reading it is expected to fetch. */
 export declare function isWaterfallHandle(handle: Pick<QueryHandle, "queryKey">): boolean;
 /**

package/dist/load.mjs

@@ -81,13 +81,10 @@ function startIfStale(entry) {
 function isFresh(entry) {
 	return entry.client.isServer ? entry.state.hasData && !isInvalidated(entry) : !isStale(entry);
 }
-/**
-* Drop pages the entry's `keepPages` turns down for the input it was just
-* loaded with, so they load again from that input's `initialPageParam`.
-*/
-function dropUnkeptPages(entry) {
+/** Whether the entry's `keepPages` takes its cached pages for the input it was just loaded with. */
+function keepsPages(entry) {
 	const keep = entry.options?.["~keep"];
-	if (keep && entry.state.hasData && !keep(entry.state.data)) reset(entry);
+	return !keep || !entry.state.hasData || keep(entry.state.data);
 }
 function waitFresh(entry, pages) {
 	if (isFresh(entry)) return Promise.resolve({ ok: true });
@@ -123,14 +120,18 @@ async function load(client, entries) {
 	}]).map((loaded) => {
 		const item = loaded.item;
 		const cached = entryOf(client, item.factory, item.input);
-		dropUnkeptPages(cached);
+		const kept = keepsPages(cached);
 		let wait;
-		if (item.kind === "prefetch") startIfStale(cached);
-		else if (isBrowserOnly(cached) && !cached.state.hasData) wait = Promise.resolve({
+		if (item.kind === "prefetch") {
+			if (kept) startIfStale(cached);
+		} else if (isBrowserOnly(cached) && !cached.state.hasData) wait = Promise.resolve({
 			error: /* @__PURE__ */ new Error(`raf-query: ${cached.hash} has \`ssr: false\`, so the server can't wait for it. Load it with prefetch() instead of ${item.kind}().`),
 			ok: false
 		});
-		else wait = (item.kind === "revalidate" ? waitFresh : waitAny)(cached, item.pages);
+		else {
+			if (!kept) reset(cached);
+			wait = (item.kind === "revalidate" ? waitFresh : waitAny)(cached, item.pages);
+		}
 		return {
 			entry: cached,
 			item,