@raf-query/core 0.13.2 → 0.15.0

package/CHANGELOG.md

@@ -1,10 +1,30 @@
 # Changelog
 
+## [0.15.0](https://github.com/KATT/raf-query/compare/0.14.0...0.15.0) (2026-11-11)
+
+### ⚠ BREAKING CHANGES
+
+* **core:** a part's link can give or change the queryFn context per request ([#251](https://github.com/KATT/raf-query/issues/251))
+
+### Features
+
+* **core:** a part's link can give or change the queryFn context per request ([#251](https://github.com/KATT/raf-query/issues/251)) ([3358dde](https://github.com/KATT/raf-query/commit/3358ddeb1a0a19b0459af55d70b6e23a05a902d5))
+
+## [0.14.0](https://github.com/KATT/raf-query/compare/0.13.2...0.14.0) (2026-11-11)
+
+### ⚠ BREAKING CHANGES
+
+- **core:** parts declare the options and queryFn context a client's queries get ([#250](https://github.com/KATT/raf-query/issues/250))
+
+### Features
+
+- **core:** parts declare the options and queryFn context a client's queries get ([#250](https://github.com/KATT/raf-query/issues/250)) ([931b7ed](https://github.com/KATT/raf-query/commit/931b7ed83837576c607b63e2dfdd1c795129cd41))
+
 ## [0.13.2](https://github.com/KATT/raf-query/compare/0.13.1...0.13.2) (2026-11-10)
 
 ### Bug Fixes
 
-* **core:** a prefetch never drops pages keepPages turns down ([#249](https://github.com/KATT/raf-query/issues/249)) ([3c66020](https://github.com/KATT/raf-query/commit/3c66020ee7562c6e2592017a1b11af94bc89e340))
+- **core:** a prefetch never drops pages keepPages turns down ([#249](https://github.com/KATT/raf-query/issues/249)) ([3c66020](https://github.com/KATT/raf-query/commit/3c66020ee7562c6e2592017a1b11af94bc89e340))
 
 ## [0.13.1](https://github.com/KATT/raf-query/compare/0.13.0...0.13.1) (2026-11-10)
 

package/README.md

@@ -1,6 +1,6 @@
 # @raf-query/core
 
-The framework-agnostic query client behind [raf-query](https://raf-query.katt.dev): a small cache that dedupes requests, keeps entries fresh, and hands out serializable handles. Retries, timeouts, refetch on focus or reconnect, polling and hydration are opt-in links, features and exports, so a client bundles only what it turns on.
+The framework-agnostic query client behind [raf-query](https://raf-query.katt.dev): a small cache that dedupes requests, keeps entries fresh, and hands out serializable handles. Retries, timeouts, refetch on focus or reconnect, polling and hydration are opt-in, as parts you give the client or exports you import, so a client bundles only what it turns on.
 
 **[Documentation](https://raf-query.katt.dev)** · [API reference](https://raf-query.katt.dev/docs/api-reference#raf-querycore) · [GitHub](https://github.com/KATT/raf-query)
 
@@ -37,7 +37,10 @@ export function issueQuery(input: { id: number }) {
 	});
 }
 
-const queryClient = createQueryClient({ links: [retry()], staleTime: 5000 });
+const queryClient = createQueryClient({
+	parts: [retry()],
+	defaults: { staleTime: 5000 },
+});
 
 const [, data] = await load(queryClient, {
 	issue: revalidate(issueQuery, { id: 1 }),
@@ -49,9 +52,9 @@ await invalidateOne(queryClient, issueQuery, { id: 1 });
 
 ## Entry points
 
-| Import            | Use                                                                                                                          |
-| ----------------- | ---------------------------------------------------------------------------------------------------------------------------- |
-| `@raf-query/core` | `createQueryClient`, query factories, `load`, the verbs, the built-in links and features, `group`, `dehydrate` and `hydrate` |
+| Import            | Use                                                                                                                                                |
+| ----------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@raf-query/core` | `createQueryClient`, query factories, `load`, the verbs, the built-in parts (`retry()`, `polling()` and so on), `group`, `dehydrate` and `hydrate` |
 
 ## License
 

package/dist/client.d.mts

@@ -1,16 +1,10 @@
 import { QueryKey } from "./keys/keys.mjs";
-import { AnyPart, AnyRoot, Decl, Declares, MetaOf, MetaOfDecl, RootTypes } from "./root.mjs";
 import { Stamp } from "./keys/targets.mjs";
-import { QueryOptions } from "./options.mjs";
+import { AnyDeclares, ContextOfDecl, Decl, Declares, NoDecl, NoParts, OptionsOfDecl, Root, RootOfParts, RootTypes } from "./root.mjs";
+import { CoreOptions, QueryOptions } from "./options.mjs";
 import { Listeners, SubscribeOptions } from "./subscribe.mjs";
 import { Entry } from "./entry.mjs";
 //#region src/client.d.ts
-type LinkFunction = (op: Operation, next: (op: Operation) => Promise<unknown>) => Promise<unknown>;
-type FeatureFunction = (client: QueryClient, signal: AbortSignal) => void;
-/** Any link, whatever `meta` it reads. */
-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.
  *
@@ -23,12 +17,19 @@ export interface Clock {
 }
 export declare const systemClock: Clock;
 /**
- * One request, as links see it. `TMeta` is what the link declares.
+ * One request, as a part's link sees it. `TDecl` is what the part declares:
+ * `options` has the fields it reads.
  *
- * @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
+ * @see https://raf-query.katt.dev/docs/links-and-features#parts
  */
-export interface Operation<TMeta extends object = object> {
+export interface Operation<TDecl extends Decl = Decl> {
   readonly client: QueryClient;
+  /**
+   * What the `queryFn` gets beside the client, key and signal: the parts'
+   * context, as the links before this one left it. Pass `next` an
+   * operation with another `context` to change it for this request.
+   */
+  readonly context: Partial<ContextOfDecl<TDecl>>;
   /** The entry's data when the request started (paged queries extend it). */
   readonly data: unknown;
   /** For paged queries: which page to add. */
@@ -36,54 +37,119 @@ export interface Operation<TMeta extends object = object> {
   readonly hasData: boolean;
   readonly hash: string;
   readonly input: unknown;
-  /** The query's `meta`, `{}` when it has none. */
-  readonly meta: TMeta;
-  readonly options: QueryOptions;
+  /** The query's options, over the client's `defaults`. */
+  readonly options: Partial<OptionsOfDecl<TDecl>> & QueryOptions;
   /** For paged queries: how many pages a first load fetches. */
   readonly pages: number | undefined;
   readonly queryKey: QueryKey;
   readonly signal: AbortSignal;
 }
+type LinkFunction = (op: Operation, next: (op: Operation) => Promise<unknown>) => Promise<unknown>;
+type SetupFunction = (client: QueryClient, signal: AbortSignal) => void;
 /**
- * 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}.
+ * One piece of a client's behavior: any of a link that wraps every request,
+ * a feature's `setup`, and values for every `queryFn`'s context. `TDecl` is
+ * what it declares: see {@link part}.
  *
- * @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
+ * @see https://raf-query.katt.dev/docs/links-and-features#parts
  */
-export type Feature<TDecl extends Decl = Decl> = FeatureFunction & Declares<TDecl>;
+export interface Part<TDecl extends Decl = NoDecl> extends Declares<TDecl> {
+  readonly context?: object;
+  readonly link?: LinkFunction;
+  readonly setup?: SetupFunction;
+}
+/** Any part, whatever it declares. */
+export interface AnyPart extends AnyDeclares {
+  readonly context?: object;
+  readonly link?: LinkFunction;
+  readonly setup?: SetupFunction;
+}
+type LinkOf<TDecl extends Decl, TNext> = (op: Operation<TDecl>, next: (op: TNext) => Promise<unknown>) => Promise<unknown>;
+interface PartSetup<TDecl extends Decl> {
+  /**
+   * A cache-wide behavior, started when a provider mounts the client and
+   * stopped by `signal`. The client is typed with this part, so it runs
+   * the factories of a builder bound to it.
+   */
+  readonly setup?: (client: QueryClient<Root<TDecl>>, signal: AbortSignal) => void;
+}
+/** The context a declaration says its part gives. */
+type DeclaredContext<TDecl extends ContextDecl> = TDecl["context"];
+/** A declaration with a `context`: its part gives it. */
+interface ContextDecl extends Decl {
+  readonly context: object;
+}
+/** What {@link part} takes for a part that declares no `context`. */
+interface PlainDefinition<TDecl extends Decl> extends PartSetup<TDecl> {
+  readonly context?: never;
+  /**
+   * 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`.
+   */
+  readonly link?: LinkOf<TDecl, Operation<TDecl>>;
+}
+/** What {@link part} takes for a part that gives its `context` for the client. */
+interface ClientContextDefinition<TDecl extends ContextDecl> extends PartSetup<TDecl> {
+  /** Merged into the context of every `queryFn` the client runs. */
+  readonly context: DeclaredContext<TDecl>;
+  /**
+   * 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`. An
+   * operation with another `context` changes it for that request.
+   */
+  readonly link?: LinkOf<TDecl, Operation<TDecl>>;
+}
+/** What {@link part} takes for a part that gives its `context` per request. */
+interface RequestContextDefinition<TDecl extends ContextDecl> extends PartSetup<TDecl> {
+  readonly context?: never;
+  /**
+   * Wraps every request, and gives each the context the part declares:
+   * `next` takes an operation whose `context` has it.
+   */
+  readonly link: LinkOf<TDecl, Operation<TDecl> & {
+    readonly context: DeclaredContext<TDecl>;
+  }>;
+}
+/** A declaration without a `context`: its part needs no definition. */
+interface OptionsDecl {
+  readonly context?: never;
+  readonly options?: object;
+}
 /**
- * A link that declares the `meta` fields it reads. A root's queries take
- * those fields only when the root has the link.
+ * A part of a client, with what it declares: the per-query `options` it
+ * reads and the `context` it gives every `queryFn`. A client's queries take
+ * those options, and get that context, only when the client has the part.
  *
  * ```ts
- * const traced = link<{ meta: { traceId?: string } }>((op, next) =>
- *   withTrace(op.meta.traceId, () => next(op)),
- * );
+ * interface Traced {
+ *   readonly options: { readonly traceId?: string };
+ * }
+ * const traced = part<Traced>({
+ *   link: (op, next) => withTrace(op.options.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>;
-/**
- * A feature that declares the `meta` fields it reads. Without `setup`, it
- * only declares them: a root's own fields, such as an `owner` its targets
- * match on.
+ * A part without a link or `setup` only declares: an app's own options, such
+ * as an `owner` its targets match on.
+ *
+ * A part gives the `context` it declares for the client, as `context`, or
+ * per request, from its link:
  *
  * ```ts
- * const ownership = feature<{ meta: { owner?: "posts-team" | "users-team" } }>();
+ * interface Session {
+ *   readonly context: { readonly token: string };
+ * }
+ * const session = part<Session>({
+ *   link: async (op, next) =>
+ *     next({ ...op, context: { ...op.context, token: await freshToken() } }),
+ * });
  * ```
  *
- * @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
+ * @see https://raf-query.katt.dev/docs/links-and-features#parts
  */
-export declare function feature<TDecl extends Decl = Decl>(setup?: FeatureFunction): Feature<TDecl>;
+export declare function part<TDecl extends OptionsDecl = NoDecl>(definition?: PlainDefinition<NoInfer<TDecl>>): Part<NoInfer<TDecl>>;
+export declare function part<TDecl extends ContextDecl>(definition: ClientContextDefinition<NoInfer<TDecl>>): Part<NoInfer<TDecl>>;
+export declare function part<TDecl extends ContextDecl>(definition: RequestContextDefinition<NoInfer<TDecl>>): Part<NoInfer<TDecl>>;
 export type ClientEvent = {
   readonly entry: Entry;
   readonly type: "added" | "removed" | "updated";
@@ -92,44 +158,47 @@ export type ClientEvent = {
   readonly type: "readers";
 };
 /**
- * What `createQueryClient` takes: links, features and the cache-wide defaults.
+ * What `createQueryClient` takes: its parts 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. */
-  readonly features?: ReadonlyArray<AnyFeature>;
-  /** Default `gcTime`: 5 minutes. Server clients never gc. */
-  readonly gcTime?: number;
+  /**
+   * Client-wide defaults for per-query options: the core's (`staleTime`,
+   * `gcTime`, `structuralSharing`) and those the parts declare. `ssr` is a
+   * query's own.
+   */
+  readonly defaults?: object;
   /** Default: no `window`. Server clients never gc and never revalidate cached data. */
   readonly isServer?: boolean;
-  /** Wrap every request, outermost first. */
-  readonly links?: ReadonlyArray<AnyLink>;
-  /** Default `staleTime`: `0`. */
-  readonly staleTime?: number;
-  /** Default `structuralSharing`: `true`. */
-  readonly structuralSharing?: boolean;
+  /**
+   * The client's behaviors. Links wrap every request, outermost first;
+   * features start while a provider has the client mounted.
+   */
+  readonly parts?: ReadonlyArray<AnyPart>;
 }
 /**
- * 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.
+ * A query cache. `TTypes` is its root's types: what its parts declare. It
+ * runs the factories of builders bound to those parts, or to fewer of them,
+ * so the bare `QueryClient` type takes any client.
  *
  * @see https://raf-query.katt.dev/docs/api-reference#the-client
  */
-export interface QueryClient<TTypes extends RootTypes = AnyRoot> {
+export interface QueryClient<TTypes extends RootTypes = NoParts> {
   /** Entries changed since the last notification. */
   readonly "~changed": Set<Entry>;
+  /** What the parts give every `queryFn` for the client; links can change it per request. */
+  readonly "~context": object;
   readonly "~entries": Map<string, Entry>;
   readonly "~events": Listeners<ClientEvent>;
   /** Orders requests and invalidations. */
   "~seq": number;
   /** Invalidations not yet older than every entry's data. */
   "~stamps": Array<Stamp>;
-  /** Phantom: the root's types, invariant. `undefined` at runtime. */
+  /** Phantom: the root's types. `undefined` at runtime. */
   readonly "~types"?: {
-    readonly root: (types: TTypes) => TTypes;
+    readonly root: TTypes;
   };
   readonly clock: Clock;
   readonly config: QueryClientConfig;
@@ -145,13 +214,18 @@ export interface QueryClient<TTypes extends RootTypes = AnyRoot> {
   }): () => void;
 }
 /**
- * Create a query client. Behaviors are opt-in: pass `links` and `features`,
- * or spread `recommended()`. The client's `meta` type is what they declare.
+ * Create a query client. Behaviors are opt-in: pass `parts`, such as
+ * `recommended()`. The client's root is what they declare.
  *
  * ```ts
- * const ownership = feature<{ meta: { owner?: "posts-team" | "users-team" } }>();
+ * interface Ownership {
+ *   readonly options: { readonly owner?: "posts-team" | "users-team" };
+ * }
  * export const makeQueryClient = () =>
- *   createQueryClient({ links: [retry()], features: [ownership], staleTime: 30_000 });
+ *   createQueryClient({
+ *     parts: [retry(), part<Ownership>()],
+ *     defaults: { staleTime: 30_000 },
+ *   });
  * ```
  *
  * Make one per request on the server (in a loader or a request-scoped
@@ -159,14 +233,12 @@ export interface QueryClient<TTypes extends RootTypes = AnyRoot> {
  *
  * @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;
-  readonly links?: TLinks;
-}): QueryClient<{
-  readonly meta: MetaOf<[...TLinks, ...TFeatures]>;
-}>;
+export declare function createQueryClient<const TParts extends ReadonlyArray<AnyPart> = []>(config?: Omit<QueryClientConfig, "defaults" | "parts"> & {
+  readonly defaults?: NoInfer<Omit<CoreOptions, "ssr"> & Partial<RootOfParts<TParts>["options"]>>;
+  readonly parts?: TParts;
+}): QueryClient<RootOfParts<TParts>>;
 /**
- * Start the client's features. Providers call it while mounted; the
+ * Start the features of the client's parts. Providers call it while mounted; the
  * returned function stops them. Mounts are counted, so features start once
  * however many providers share the client, and stop with the last.
  */

package/dist/client.mjs

@@ -7,44 +7,22 @@ const systemClock = {
 	now: () => Date.now(),
 	setTimeout: (callback, ms) => setTimeout(callback, ms)
 };
-/**
-* A link that declares the `meta` fields it reads. A root's queries take
-* those fields only when the root has the link.
-*
-* ```ts
-* const traced = link<{ meta: { traceId?: string } }>((op, next) =>
-*   withTrace(op.meta.traceId, () => next(op)),
-* );
-* ```
-*
-* @see https://raf-query.katt.dev/docs/links-and-features#links-and-features
-*/
-function link(run) {
-	return run;
-}
-const noop = () => {};
-/**
-* A feature that declares the `meta` fields it reads. Without `setup`, it
-* only declares them: a root's own fields, such as an `owner` its targets
-* match on.
-*
-* ```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;
+function part(definition = {}) {
+	return definition;
 }
 /**
-* Create a query client. Behaviors are opt-in: pass `links` and `features`,
-* or spread `recommended()`. The client's `meta` type is what they declare.
+* Create a query client. Behaviors are opt-in: pass `parts`, such as
+* `recommended()`. The client's root is what they declare.
 *
 * ```ts
-* const ownership = feature<{ meta: { owner?: "posts-team" | "users-team" } }>();
+* interface Ownership {
+*   readonly options: { readonly owner?: "posts-team" | "users-team" };
+* }
 * export const makeQueryClient = () =>
-*   createQueryClient({ links: [retry()], features: [ownership], staleTime: 30_000 });
+*   createQueryClient({
+*     parts: [retry(), part<Ownership>()],
+*     defaults: { staleTime: 30_000 },
+*   });
 * ```
 *
 * Make one per request on the server (in a loader or a request-scoped
@@ -57,6 +35,7 @@ function createQueryClient(config = {}) {
 	const entries = /* @__PURE__ */ new Map();
 	return {
 		"~changed": /* @__PURE__ */ new Set(),
+		"~context": Object.assign({}, ...(config.parts ?? []).map((one) => one.context)),
 		"~entries": entries,
 		"~events": events,
 		"~seq": 0,
@@ -74,9 +53,13 @@ function createQueryClient(config = {}) {
 		}
 	};
 }
+/** The client's parts, as the kernel runs them. */
+function partsOf(client) {
+	return client.config.parts ?? [];
+}
 const mounted = /* @__PURE__ */ new WeakMap();
 /**
-* Start the client's features. Providers call it while mounted; the
+* Start the features of the client's parts. Providers call it while mounted; the
 * returned function stops them. Mounts are counted, so features start once
 * however many providers share the client, and stop with the last.
 */
@@ -88,7 +71,7 @@ function mount(client) {
 			count: 0
 		};
 		mounted.set(client, current);
-		for (const start of client.config.features ?? []) start(client, current.controller.signal);
+		for (const one of partsOf(client)) one.setup?.(client, current.controller.signal);
 	}
 	const shared = current;
 	shared.count += 1;
@@ -101,4 +84,4 @@ function mount(client) {
 	};
 }
 //#endregion
-export { createQueryClient, feature, link, mount, systemClock };
+export { createQueryClient, mount, part, partsOf, systemClock };

package/dist/entry.mjs

@@ -1,4 +1,5 @@
 import { listeners } from "./subscribe.mjs";
+import { partsOf } from "./client.mjs";
 import { isObject } from "./guards.mjs";
 import { hashKey } from "./keys/keys.mjs";
 import { matches } from "./keys/targets.mjs";
@@ -52,8 +53,13 @@ function newPending(entry) {
 	entry.pendingThenable = next;
 	entry.thenable = next.promise;
 }
+/** One of the core's options for the entry: the query's, or else the client's default. */
+function optionOf(entry, name) {
+	const defaults = entry.client.config.defaults;
+	return entry.options?.[name] ?? defaults?.[name];
+}
 function gcTime(entry) {
-	return entry.options?.gcTime ?? entry.client.config.gcTime ?? fiveMinutes;
+	return optionOf(entry, "gcTime") ?? fiveMinutes;
 }
 function scheduleGc(entry) {
 	const client = entry.client;
@@ -136,13 +142,13 @@ function isBrowserOnly(entry) {
 function isStale(entry) {
 	const state = entry.state;
 	if (!state.hasData) return true;
-	const staleTime = entry.options?.staleTime ?? entry.client.config.staleTime ?? 0;
+	const staleTime = optionOf(entry, "staleTime") ?? 0;
 	return entry.client.clock.now() - state.updatedAt >= staleTime || isInvalidated(entry);
 }
 /** Write data. `startedAt` orders it against invalidations. */
 function write(entry, data, updatedAt, startedAt) {
 	const previous = entry.state;
-	const next = (entry.options?.structuralSharing ?? entry.client.config.structuralSharing ?? true) && previous.hasData ? replaceEqualDeep(previous.data, data) : data;
+	const next = (optionOf(entry, "structuralSharing") ?? true) && previous.hasData ? replaceEqualDeep(previous.data, data) : data;
 	entry.requestedAt = Math.max(entry.requestedAt, startedAt);
 	if (entry.pendingThenable) {
 		entry.pendingThenable.resolve(next);
@@ -215,18 +221,19 @@ function terminal(op) {
 		const options = op.options;
 		const paged = options["~run"];
 		resolve(paged ? paged(op) : options.queryFn({
+			...op.context,
 			client: op.client,
-			meta: op.meta,
 			queryKey: op.queryKey,
 			signal: op.signal
 		}));
 	});
 }
 function chain(op) {
-	const links = op.client.config.links ?? [];
+	const parts = partsOf(op.client);
 	const call = (index, current) => {
-		const link = links[index];
-		return link ? link(current, (next) => call(index + 1, next)) : terminal(current);
+		const one = parts[index];
+		if (!one) return terminal(current);
+		return one.link ? one.link(current, (next) => call(index + 1, next)) : call(index + 1, current);
 	};
 	return call(0, op);
 }
@@ -257,13 +264,16 @@ function fetchEntry(entry, request = {}) {
 	const state = entry.state;
 	chain({
 		client,
+		context: client["~context"],
 		data: state.data,
 		direction: request.direction,
 		hasData: state.hasData,
 		hash: entry.hash,
 		input: entry.input,
-		meta: options.meta ?? {},
-		options,
+		options: {
+			...client.config.defaults,
+			...options
+		},
 		pages: request.pages,
 		queryKey: entry.key,
 		signal: run.controller.signal

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

@@ -1,17 +1,21 @@
-import { Feature } from "../../client.mjs";
+import { Part } from "../../client.mjs";
 //#region src/features/focus-refetch/focus-refetch.d.ts
-/** What `focusRefetch()` reads from a query's `meta`. */
-export interface FocusRefetchMeta {
-  /** `false`: don't refetch this query on focus. */
-  readonly refetchOnWindowFocus?: boolean;
+/**
+ * What `focusRefetch()` declares.
+ *
+ * @see https://raf-query.katt.dev/docs/window-focus-refetching
+ */
+export interface FocusRefetch {
+  readonly options: {
+    /** `false`: don't refetch this query on focus. */
+    readonly refetchOnWindowFocus?: boolean;
+  };
 }
 /**
  * Refetch read, stale queries when the window regains focus, except those
- * with `meta: { refetchOnWindowFocus: false }`.
+ * with `refetchOnWindowFocus: false`.
  *
  * @see https://raf-query.katt.dev/docs/window-focus-refetching
  */
-export declare function focusRefetch(): Feature<{
-  readonly meta: FocusRefetchMeta;
-}>;
+export declare function focusRefetch(): Part<FocusRefetch>;
 //#endregion

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

@@ -1,20 +1,20 @@
-import { feature } from "../../client.mjs";
+import { part } from "../../client.mjs";
 import { refetchStaleReads } from "../shared.mjs";
 //#region src/features/focus-refetch/focus-refetch.ts
 /**
 * Refetch read, stale queries when the window regains focus, except those
-* with `meta: { refetchOnWindowFocus: false }`.
+* with `refetchOnWindowFocus: false`.
 *
 * @see https://raf-query.katt.dev/docs/window-focus-refetching
 */
 function focusRefetch() {
-	return feature((client, signal) => {
+	return part({ setup: (client, signal) => {
 		const onFocus = () => {
 			if (document.visibilityState === "visible") refetchStaleReads(client, "refetchOnWindowFocus");
 		};
 		document.addEventListener("visibilitychange", onFocus, { signal });
 		window.addEventListener("focus", onFocus, { signal });
-	});
+	} });
 }
 //#endregion
 export { focusRefetch };

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

@@ -1,16 +1,20 @@
-import { Feature } from "../../client.mjs";
+import { Part } from "../../client.mjs";
 //#region src/features/polling/polling.d.ts
-/** What `polling()` reads from a query's `meta`. */
-export interface PollingMeta {
-  /** Refetch every `n` ms while the query is read. */
-  readonly refetchInterval?: number | false;
+/**
+ * What `polling()` declares.
+ *
+ * @see https://raf-query.katt.dev/docs/polling
+ */
+export interface Polling {
+  readonly options: {
+    /** Refetch every `n` ms while the query is read. */
+    readonly refetchInterval?: number | false;
+  };
 }
 /**
- * Refetch read queries every `meta.refetchInterval` ms.
+ * Refetch read queries every `refetchInterval` ms.
  *
  * @see https://raf-query.katt.dev/docs/polling
  */
-export declare function polling(): Feature<{
-  readonly meta: PollingMeta;
-}>;
+export declare function polling(): Part<Polling>;
 //#endregion