@raf-query/core 0.13.2 → 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/options.d.mts

@@ -1,40 +1,35 @@
 import { QueryKey } from "./keys/keys.mjs";
-import { AnyRoot, DefaultTypes, RootOf, RootTag, RootTypes } from "./root.mjs";
+import { NoParts, RootOf, RootTag, RootTypes, SetsOf } from "./root.mjs";
 import { QueryClient } from "./client.mjs";
 //#region src/options.d.ts
 /**
- * What a `queryFn` gets: the client making the request, the query's key,
- * `meta` and abort `signal`.
+ * What a `queryFn` gets: the client making the request, the query's key and
+ * abort `signal`, and what the client's parts give every `queryFn`.
  *
  * @see https://raf-query.katt.dev/docs/query-functions#the-query-function-context
  */
-export interface QueryFunctionContext<TKey extends QueryKey = QueryKey> {
+export type QueryFunctionContext<TKey extends QueryKey = QueryKey, TTypes extends RootTypes = NoParts> = TTypes["context"] & {
   /**
-   * The client making the request. A server makes one per request, so it
-   * keys per-request services, such as an API client with the request's
-   * cookies.
+   * The client making the request. A server makes one per request, so
+   * what its parts give the context belongs to that request, such as an
+   * API client with the request's cookies.
    */
-  readonly client: QueryClient;
-  /** The query's `meta`, typed by its root where the query is defined. */
-  readonly meta: object;
+  readonly client: QueryClient<TTypes>;
   readonly queryKey: TKey;
   /** Aborted when the request is restarted or its entry is removed. */
   readonly signal: AbortSignal;
-}
+};
 declare const dataTag: unique symbol;
 declare const queryFnDataTag: unique symbol;
-/** Options every query takes. */
-export interface BaseOptions<TKey extends QueryKey, TTypes extends RootTypes = RootTypes> {
+/**
+ * The per-query options the core reads, whatever parts the client has. A
+ * client's `defaults` set them for every query.
+ *
+ * @see https://raf-query.katt.dev/docs/important-defaults#changing-the-defaults
+ */
+export interface CoreOptions {
   /** How long an entry with no reader stays cached. Default 5 minutes; never on the server. */
   readonly gcTime?: number;
-  /**
-   * Settings for the root's links and features, and data for targets: the
-   * fields the root's parts declare, such as `retry` with the `retry()`
-   * link.
-   */
-  readonly meta?: NoInfer<Partial<TTypes["meta"]>>;
-  /** A plain array, usually built by a `group()`. Handles keep its literal type. */
-  readonly queryKey: TKey;
   /**
    * `false` for a query only a browser can run (a permission, the service
    * worker, `localStorage`): a server client never starts it, never sends
@@ -49,12 +44,29 @@ export interface BaseOptions<TKey extends QueryKey, TTypes extends RootTypes = R
   /** Keep the deeply equal parts of new data, so they keep their identity. Default `true`. */
   readonly structuralSharing?: boolean;
 }
+/** Options every query takes. */
+export interface BaseOptions<TKey extends QueryKey> extends CoreOptions {
+  /** A plain array, usually built by a `group()`. Handles keep its literal type. */
+  readonly queryKey: TKey;
+}
+/**
+ * The options a builder bound to `T` lets a query set, beside its key and
+ * `queryFn`: the core's, and those `T`'s parts declare. For a fragment
+ * several factories share:
+ *
+ * ```ts
+ * const pinned = { retry: false, staleTime: Infinity } satisfies OptionsOf<typeof makeQueryClient>;
+ * ```
+ *
+ * @see https://raf-query.katt.dev/docs/links-and-features#typing-options-by-the-client
+ */
+export type OptionsOf<T> = CoreOptions & Partial<SetsOf<T>["options"]>;
 /**
  * What `queryOptions` and `infiniteQueryOptions` return.
  *
  * @see https://raf-query.katt.dev/docs/api-reference#query-factories
  */
-export interface QueryOptions<TKey extends QueryKey = QueryKey, TQueryFnData = unknown, TData = TQueryFnData, TTypes extends RootTypes = RootTypes> extends BaseOptions<TKey, TTypes> {
+export interface QueryOptions<TKey extends QueryKey = QueryKey, TQueryFnData = unknown, TData = TQueryFnData, TTypes extends RootTypes = RootTypes> extends BaseOptions<TKey> {
   /** Set by `infiniteQueryOptions` from `keepPages`: whether `load` keeps the cached pages. */
   readonly "~keep"?: (data: never) => boolean;
   /** Phantom: the root the builder is bound to. Never set at runtime. */
@@ -91,17 +103,18 @@ type Awaitable<T> = PromiseLike<T> | T;
  */
 export type FromQueryFn<T> = T extends unknown ? T : never;
 /**
- * `queryOptions`, with `meta` checked against the root `TTypes`.
+ * `queryOptions` 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 QueryOptionsBuilder<TTypes extends RootTypes> {
-  <const TKey extends QueryKey, TChunk, TData>(options: BaseOptions<TKey, TTypes> & {
-    readonly queryFn: (context: QueryFunctionContext<TKey>) => AsyncIterable<TChunk>;
+export interface QueryOptionsBuilder<TTypes extends RootTypes, TSets extends RootTypes = TTypes> {
+  <const TKey extends QueryKey, TChunk, TData>(options: BaseOptions<TKey> & Partial<TSets["options"]> & {
+    readonly queryFn: (context: QueryFunctionContext<TKey, TTypes>) => AsyncIterable<TChunk>;
     readonly stream: StreamOptions<TData, TChunk>;
   }): QueryOptions<TKey, TData, TData, TTypes>;
-  <const TKey extends QueryKey, TQueryFnData, TData = TQueryFnData>(options: BaseOptions<TKey, TTypes> & {
-    readonly queryFn: (context: QueryFunctionContext<TKey>) => Awaitable<TQueryFnData>;
+  <const TKey extends QueryKey, TQueryFnData, TData = TQueryFnData>(options: BaseOptions<TKey> & Partial<TSets["options"]> & {
+    readonly queryFn: (context: QueryFunctionContext<TKey, TTypes>) => Awaitable<TQueryFnData>;
     readonly select?: (data: FromQueryFn<TQueryFnData>) => TData;
   }): QueryOptions<TKey, TQueryFnData, TData, TTypes>;
 }
@@ -120,27 +133,36 @@ export interface QueryOptionsBuilder<TTypes extends RootTypes> {
  * fold its chunks into the data. Readers get the data after the first chunk,
  * and every later chunk updates it in place.
  *
- * Its `meta` is any record. To check `meta` against a client's links and
- * features, use the builder {@link bindQueryOptions} returns.
+ * It takes the core's options only, and its factories run on any client.
+ * For the options and the `queryFn` context a client's parts declare, use
+ * the builder {@link bindQueryOptions} returns.
  *
  * @see https://raf-query.katt.dev/docs/query-factories
  */
-export declare const queryOptions: QueryOptionsBuilder<DefaultTypes>;
+export declare const queryOptions: QueryOptionsBuilder<NoParts>;
 /**
- * `queryOptions` bound to a root: `meta` takes the fields the root's links
- * and features declare, and verbs take only that root's clients. `T` is the
- * client's type, or the type of a function that makes it. Bind once per app:
+ * `queryOptions` bound to a root: it takes the options the root's parts
+ * declare, its `queryFn`s get their context, and its factories run on the
+ * clients that have those parts. `T` is the client's type, or the type of a
+ * function that makes it. Bind once per client:
  *
  * ```ts
  * // raf.ts
  * export const queryOptions = bindQueryOptions<typeof makeQueryClient>();
  * ```
  *
+ * A library names the parts its factories need by their declarations, and
+ * as `Optional` the ones whose options it sets where the client has them:
+ *
+ * ```ts
+ * const queryOptions = bindQueryOptions<Convex & Optional<Retry>>();
+ * ```
+ *
  * It returns `queryOptions` itself; only the types change.
  *
- * @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 bindQueryOptions<T>(): QueryOptionsBuilder<RootOf<T>>;
+export declare function bindQueryOptions<T>(): QueryOptionsBuilder<RootOf<T>, SetsOf<T>>;
 /**
  * A function of the query's input that returns its options. The input is a
  * method parameter typed `unknown`, which TypeScript checks bivariantly:
@@ -198,8 +220,8 @@ export type InputOf<TFactory extends QueryFactory> = Parameters<TFactory> extend
 export type InputArgs<TFactory extends QueryFactory> = Parameters<TFactory> extends [] ? [] : Parameters<TFactory> extends [infer TInput, ...Array<unknown>] ? [input: TInput] : [input?: Parameters<TFactory>[0]];
 /** A factory's key type, the way handles carry it. */
 export type KeyOf<TFactory extends QueryFactory> = ReturnType<TFactory>["queryKey"];
-/** The root a factory's builder is bound to; any root for an unbound one. */
+/** The root a factory's builder is bound to: what the factory needs of a client. */
 export type RootOfFactory<TFactory extends QueryFactory> = ReturnType<TFactory> extends {
   readonly "~root"?: RootTag<infer TTypes>;
-} ? TTypes extends DefaultTypes ? AnyRoot : TTypes : AnyRoot;
+} ? TTypes : NoParts;
 //#endregion