@raf-query/core 0.4.5 → 0.5.1

package/CHANGELOG.md

@@ -1,8 +1,24 @@
 # Changelog
 
+## [0.5.1](https://github.com/KATT/raf-query/compare/0.5.0...0.5.1) (2026-10-14)
+
+### Features
+
+* raf-query logo, brand colors, and a system / light / dark switcher ([#68](https://github.com/KATT/raf-query/issues/68)) ([9ae09c6](https://github.com/KATT/raf-query/commit/9ae09c63b4f60f4109a8fa6389b8b4f7adfd2ab8))
+
+## [0.5.0](https://github.com/KATT/raf-query/compare/0.4.5...0.5.0) (2026-10-14)
+
+### ⚠ BREAKING CHANGES
+
+- type options by a bag instead of positional type arguments ([#69](https://github.com/KATT/raf-query/issues/69))
+
+### Features
+
+- type options by a bag instead of positional type arguments ([#69](https://github.com/KATT/raf-query/issues/69)) ([df7ef81](https://github.com/KATT/raf-query/commit/df7ef816d33039166686cfe1113333bb6c444a27))
+
 ## [0.4.5](https://github.com/KATT/raf-query/compare/0.4.4...0.4.5) (2026-10-14)
 
-* trim the READMEs, give each package its own, and warn that raf-query is early on the docs site ([#70](https://github.com/KATT/raf-query/issues/70)) ([2c06462](https://github.com/KATT/raf-query/commit/2c0646291f5fc45d2d64bc43c52f3e089c46ce05))
+- trim the READMEs, give each package its own, and warn that raf-query is early on the docs site ([#70](https://github.com/KATT/raf-query/issues/70)) ([2c06462](https://github.com/KATT/raf-query/commit/2c0646291f5fc45d2d64bc43c52f3e089c46ce05))
 
 ## [0.4.4](https://github.com/KATT/raf-query/compare/0.4.3...0.4.4) (2026-10-14)
 

package/dist/cache.d.mts

@@ -1,7 +1,7 @@
 import { QueryKey } from "./key.mjs";
 import { DataOf, EnsuredQueryHandle, ErrorOf, InputArgs, InputOf, LoadOptions, QueryBehavior, QueryFactory, QueryHandle, ServicesOf } from "./options.mjs";
 import { DehydrateOptions, DehydratedState, DehydratedStream, HydrateOptions } from "./hydration.mjs";
-import { CancelledError, Of, Query, State, query_d_exports } from "./query.mjs";
+import { CancelledError, Query, State, query_d_exports } from "./query.mjs";
 import { Context, Effect, Layer, Option, Scope, Stream } from "effect";
 declare namespace cache_d_exports {
   export { Config, Event, Filter, LoadArgs, QueryCache, Target, TypeId, Updater, isQueryCache, layer, make };
@@ -94,12 +94,12 @@ export interface QueryCache {
    * but its requests run with this fiber's services from now on. For
    * bindings; apps use the verbs.
    */
-  getQuery<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Effect.Effect<Of<TFactory>, never, ServicesOf<TFactory>>;
+  getQuery<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Effect.Effect<Query<TFactory>, never, ServicesOf<TFactory>>;
   /**
    * `getQuery`, synchronously, for renders. Leaves the entry's services as
    * they are: the cache's, or the latest verb caller's.
    */
-  getQueryUnsafe<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Of<TFactory>;
+  getQueryUnsafe<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Query<TFactory>;
   /**
    * Write dehydrated entries. Existing entries only take newer data; pending
    * entries resume the sender's request.

package/dist/entry.d.mts

@@ -83,7 +83,7 @@ export interface Entry extends Query {
   readonly tasks: Tasks;
 }
 export declare function isQuery(value: unknown): value is Query;
-export declare function entryOf<TData, TFactory extends QueryFactory, TError>(query: Query<TData, TFactory, TError>): Entry;
+export declare function entryOf<TFactory extends QueryFactory>(query: Query<TFactory>): Entry;
 export declare function emit(cache: CacheState, event: Event): void;
 export declare function make(cache: CacheState, key: QueryKey, hash: string): Entry;
 export declare function now(entry: Entry): number;

package/dist/hydration.d.mts

@@ -76,7 +76,7 @@ export declare class RedactedError extends RedactedError_base<{
   get message(): string;
 }
 /** The default dehydrate filter: entries with data or a request in flight. */
-export declare function canDehydrate<TData, TFactory extends QueryFactory, TError>(query: Query<TData, TFactory, TError>): boolean;
+export declare function canDehydrate<TFactory extends QueryFactory>(query: Query<TFactory>): boolean;
 /** Snapshot one entry for transfer. */
-export declare function dehydrateQuery<TData, TFactory extends QueryFactory, TError>(query: Query<TData, TFactory, TError>, options?: DehydrateOptions): Effect.Effect<DehydratedQuery>;
+export declare function dehydrateQuery<TFactory extends QueryFactory>(query: Query<TFactory>, options?: DehydrateOptions): Effect.Effect<DehydratedQuery>;
 //#endregion

package/dist/index.d.mts

@@ -1,9 +1,9 @@
 import { platform_d_exports } from "./platform.mjs";
 import { QueryKey, hashKey, matchesKey } from "./key.mjs";
-import { AnyQueryOptions, DataOf, EnsuredQueryHandle, ErrorOf, InfiniteData, InfiniteQueryOptions, InputArgs, InputOf, IsPaged, LoadOptions, PageFunctionContext, PageOf, QueryBehavior, QueryFactory, QueryFnResult, QueryFunctionContext, QueryHandle, QueryMeta, QueryOptions, Register, RetryPolicy, ServicesOf, infiniteQueryOptions, queryOptions } from "./options.mjs";
+import { AnyQueryOptions, DataOf, EnsuredQueryHandle, ErrorOf, InfiniteData, InfiniteQueryOptions, InfiniteQueryTypes, InputArgs, InputOf, IsPaged, LoadOptions, PageFunctionContext, PageOf, QueryBehavior, QueryFactory, QueryFnResult, QueryFunctionContext, QueryHandle, QueryMeta, QueryOptions, QueryTypes, Register, RetryPolicy, ServicesOf, infiniteQueryOptions, queryOptions } from "./options.mjs";
 import { DehydrateOptions, DehydratedQuery, DehydratedResult, DehydratedState, DehydratedStream, HydrateOptions, RedactedError, canDehydrate, dehydrateQuery } from "./hydration.mjs";
 import { cache_d_exports } from "./cache.mjs";
 import { Thenable } from "./thenable.mjs";
 import { query_d_exports } from "./query.mjs";
 import { observer_d_exports } from "./observer.mjs";
-export { type AnyQueryOptions, type DataOf, type DehydrateOptions, type DehydratedQuery, type DehydratedResult, type DehydratedState, type DehydratedStream, type EnsuredQueryHandle, type ErrorOf, type HydrateOptions, type InfiniteData, type InfiniteQueryOptions, type InputArgs, type InputOf, type IsPaged, type LoadOptions, type PageFunctionContext, type PageOf, platform_d_exports as Platform, query_d_exports as Query, type QueryBehavior, cache_d_exports as QueryCache, type QueryFactory, type QueryFnResult, type QueryFunctionContext, type QueryHandle, type QueryKey, type QueryMeta, observer_d_exports as QueryObserver, type QueryOptions, RedactedError, type Register, type RetryPolicy, type ServicesOf, type Thenable, canDehydrate, dehydrateQuery, hashKey, infiniteQueryOptions, matchesKey, queryOptions };
+export { type AnyQueryOptions, type DataOf, type DehydrateOptions, type DehydratedQuery, type DehydratedResult, type DehydratedState, type DehydratedStream, type EnsuredQueryHandle, type ErrorOf, type HydrateOptions, type InfiniteData, type InfiniteQueryOptions, type InfiniteQueryTypes, type InputArgs, type InputOf, type IsPaged, type LoadOptions, type PageFunctionContext, type PageOf, platform_d_exports as Platform, query_d_exports as Query, type QueryBehavior, cache_d_exports as QueryCache, type QueryFactory, type QueryFnResult, type QueryFunctionContext, type QueryHandle, type QueryKey, type QueryMeta, observer_d_exports as QueryObserver, type QueryOptions, type QueryTypes, RedactedError, type Register, type RetryPolicy, type ServicesOf, type Thenable, canDehydrate, dehydrateQuery, hashKey, infiniteQueryOptions, matchesKey, queryOptions };

package/dist/observer.d.mts

@@ -1,5 +1,5 @@
 import { QueryKey } from "./key.mjs";
-import { QueryFactory } from "./options.mjs";
+import { DataOf, QueryFactory } from "./options.mjs";
 import { Thenable } from "./thenable.mjs";
 import { Query, query_d_exports } from "./query.mjs";
 import { Effect, Pipeable, Stream } from "effect";
@@ -57,45 +57,46 @@ export interface Result<TData = unknown> {
   readonly updatedAt: number;
 }
 export type ResultKey = keyof Result;
-export interface QueryObserver<TData = unknown, TFactory extends QueryFactory = QueryFactory> extends Pipeable.Pipeable {
+/** An observer of a factory's queries; its results hold the factory's {@link DataOf}. */
+export interface QueryObserver<TFactory extends QueryFactory = QueryFactory> extends Pipeable.Pipeable {
   /** The options set by the latest `make` or {@link setOptionsUnsafe}. */
   readonly options: Options;
   /** The observed query. */
-  readonly query: Query<TData, TFactory>;
+  readonly query: Query<TFactory>;
   readonly [TypeId]: {
-    readonly _A: (_: never) => TData;
+    readonly _A: (_: never) => DataOf<TFactory>;
   };
 }
 export declare function isQueryObserver(value: unknown): value is QueryObserver;
 /** Observe `query`. Doesn't subscribe to it until the observer has a listener. */
-export declare function makeUnsafe<TData, TFactory extends QueryFactory>(query: Query<TData, TFactory>, options?: Options): QueryObserver<TData, TFactory>;
+export declare function makeUnsafe<TFactory extends QueryFactory>(query: Query<TFactory>, options?: Options): QueryObserver<TFactory>;
 /** {@link makeUnsafe}, as an Effect. */
-export declare function make<TData, TFactory extends QueryFactory>(query: Query<TData, TFactory>, options?: Options): Effect.Effect<QueryObserver<TData, TFactory>>;
+export declare function make<TFactory extends QueryFactory>(query: Query<TFactory>, options?: Options): Effect.Effect<QueryObserver<TFactory>>;
 /** The current result. */
-export declare function getUnsafe<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>): Result<TData>;
+export declare function getUnsafe<TFactory extends QueryFactory>(self: QueryObserver<TFactory>): Result<DataOf<TFactory>>;
 /** {@link getUnsafe}, as an Effect. */
-export declare function get<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>): Effect.Effect<Result<TData>>;
+export declare function get<TFactory extends QueryFactory>(self: QueryObserver<TFactory>): Effect.Effect<Result<DataOf<TFactory>>>;
 /**
  * The result for `query` with `options` right now, without switching to
  * them. Bindings call this during render, before `setOptionsUnsafe` commits.
  */
-export declare function getOptimisticResultUnsafe<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>, query: Query<TData, TFactory>, options: Options): Result<TData>;
+export declare function getOptimisticResultUnsafe<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, query: Query<TFactory>, options: Options): Result<DataOf<TFactory>>;
 /** Observe `query` with `options` from now on. */
-export declare function setOptionsUnsafe<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>, query: Query<TData, TFactory>, options: Options): void;
+export declare function setOptionsUnsafe<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, query: Query<TFactory>, options: Options): void;
 /** Listen for result changes. The first listener subscribes to the query. */
-export declare function subscribeUnsafe<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>, listener: () => void): () => void;
+export declare function subscribeUnsafe<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, listener: () => void): () => void;
 /**
  * The current result, then every change listeners are notified of. Counts
  * as a listener while the stream runs, so the query counts as read.
  */
-export declare function changes<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>): Stream.Stream<Result<TData>>;
+export declare function changes<TFactory extends QueryFactory>(self: QueryObserver<TFactory>): Stream.Stream<Result<DataOf<TFactory>>>;
 /**
  * Wrap `result` so that reading a property marks it tracked. Once any
  * property is tracked, listeners are only notified when a tracked one
  * changes.
  */
-export declare function trackResult<TData, TFactory extends QueryFactory, TResult extends Result<TData>>(self: QueryObserver<TData, TFactory>, result: TResult): TResult;
+export declare function trackResult<TFactory extends QueryFactory, TResult extends Result<DataOf<TFactory>>>(self: QueryObserver<TFactory>, result: TResult): TResult;
 /** Mark `name` as read, for bindings that track access themselves. */
-export declare function trackProp<TData, TFactory extends QueryFactory>(self: QueryObserver<TData, TFactory>, name: ResultKey): void;
+export declare function trackProp<TFactory extends QueryFactory>(self: QueryObserver<TFactory>, name: ResultKey): void;
 //#endregion
 export { observer_d_exports };

package/dist/options.d.mts

@@ -1,12 +1,44 @@
 import { QueryKey } from "./key.mjs";
 import { Effect, Schedule } from "effect";
 //#region src/options.d.ts
+/**
+ * The types of a plain query: what its `queryFn` resolves to, and for an
+ * Effect `queryFn`, its error and the services it needs. `error` defaults to
+ * `unknown` (promises reject with anything), `services` to `never`.
+ *
+ * ```ts
+ * type PostOptions = QueryOptions<{ data: Post }>;
+ * ```
+ */
+export interface QueryTypes {
+  readonly data: unknown;
+  readonly error?: unknown;
+  readonly services?: unknown;
+}
+/**
+ * The types of a paged query: one page, the param that loads it, and as in
+ * {@link QueryTypes}, an Effect `queryFn`'s error and services.
+ */
+export interface InfiniteQueryTypes {
+  readonly error?: unknown;
+  readonly page: unknown;
+  readonly pageParam: unknown;
+  readonly services?: unknown;
+}
+/** `error` of a types bag, `unknown` when it has none. */
+type ErrorIn<TTypes> = TTypes extends {
+  readonly error: infer TError;
+} ? TError : unknown;
+/** `services` of a types bag, `never` when it has none. */
+type ServicesIn<TTypes> = TTypes extends {
+  readonly services: infer TServices;
+} ? TServices : never;
 /**
  * What a `queryFn` may return: a value, a promise, or an `Effect`. An
  * Effect's error type becomes the query's (promises reject with `unknown`),
  * and the services it needs become requirements of the verbs that start it.
  */
-export type QueryFnResult<TData, TError = unknown, TServices = never> = TData | PromiseLike<TData> | Effect.Effect<TData, TError, TServices>;
+export type QueryFnResult<TTypes extends QueryTypes> = TTypes["data"] | PromiseLike<TTypes["data"]> | Effect.Effect<TTypes["data"], ErrorIn<TTypes>, ServicesIn<TTypes>>;
 /**
  * App-wide types, filled in by module augmentation. Declare `queryMeta` to
  * type every query's `meta`. Augment the package you import from;
@@ -83,29 +115,50 @@ interface ServicesField<TServices> {
    */
   readonly [servicesType]?: () => TServices;
 }
-export interface QueryOptions<TData, TError = unknown, TServices = never> extends QueryBehavior, ServicesField<TServices> {
+export interface QueryOptions<TTypes extends QueryTypes> extends QueryBehavior, ServicesField<ServicesIn<TTypes>> {
   readonly kind: "query";
-  queryFn(context: QueryFunctionContext): QueryFnResult<TData, TError, TServices>;
+  queryFn(context: QueryFunctionContext): QueryFnResult<TTypes>;
   readonly queryKey: QueryKey;
 }
-export interface InfiniteQueryOptions<TPage, TPageParam, TError = unknown, TServices = never> extends QueryBehavior, ServicesField<TServices> {
+/**
+ * The functions of paged options, typed by the page and page param types
+ * themselves. Typed through the bag, inference breaks: TypeScript fixes
+ * every type parameter a contextually typed parameter's type mentions, so
+ * `context` would fix the page type before `queryFn`'s return could infer it.
+ */
+interface PageFunctions<TPage, TPageParam, TResult> {
   /** Param for the page after `lastPage`, or `null` / `undefined` at the end. */
   getNextPageParam(lastPage: TPage, pages: ReadonlyArray<TPage>, lastPageParam: TPageParam, pageParams: ReadonlyArray<TPageParam>): TPageParam | null | undefined;
   /** Param for the page before `firstPage`, or `null` / `undefined` at the start. */
   getPreviousPageParam?(firstPage: TPage, pages: ReadonlyArray<TPage>, firstPageParam: TPageParam, pageParams: ReadonlyArray<TPageParam>): TPageParam | null | undefined;
-  readonly initialPageParam: TPageParam;
+  queryFn(context: PageFunctionContext<TPageParam>): TResult;
+}
+export interface InfiniteQueryOptions<TTypes extends InfiniteQueryTypes> extends PageFunctions<TTypes["page"], TTypes["pageParam"], QueryFnResult<{
+  data: TTypes["page"];
+  error: ErrorIn<TTypes>;
+  services: ServicesIn<TTypes>;
+}>>, QueryBehavior, ServicesField<ServicesIn<TTypes>> {
+  readonly initialPageParam: TTypes["pageParam"];
   readonly kind: "infinite";
   /** Keep at most this many pages; the far end is dropped when paging. */
   readonly maxPages?: number;
-  queryFn(context: PageFunctionContext<TPageParam>): QueryFnResult<TPage, TError, TServices>;
   readonly queryKey: QueryKey;
 }
 /** Data of a paged query. */
-export interface InfiniteData<TPage, TPageParam = unknown> {
-  readonly pageParams: ReadonlyArray<TPageParam>;
-  readonly pages: ReadonlyArray<TPage>;
+export interface InfiniteData<TTypes extends Pick<InfiniteQueryTypes, "page" | "pageParam">> {
+  readonly pageParams: ReadonlyArray<TTypes["pageParam"]>;
+  readonly pages: ReadonlyArray<TTypes["page"]>;
 }
-export type AnyQueryOptions = QueryOptions<unknown, unknown, unknown> | InfiniteQueryOptions<unknown, unknown, unknown, unknown>;
+export type AnyQueryOptions = QueryOptions<{
+  data: unknown;
+  error: unknown;
+  services: unknown;
+}> | InfiniteQueryOptions<{
+  error: unknown;
+  page: unknown;
+  pageParam: unknown;
+  services: unknown;
+}>;
 /**
  * Typed options for a query factory:
  *
@@ -120,10 +173,34 @@ export type AnyQueryOptions = QueryOptions<unknown, unknown, unknown> | Infinite
  *
  * A `queryFn` Effect may need services; they're inferred, and every verb
  * that can start the query requires them.
+ *
+ * The type parameters are only there for TypeScript to infer the types bag
+ * from `queryFn`; it can't infer a bag's members.
  */
-export declare function queryOptions<TData, TError = unknown, TServices = never>(options: Omit<QueryOptions<TData, TError, TServices>, "kind">): QueryOptions<TData, TError, TServices>;
-/** Typed options for a paged query factory. */
-export declare function infiniteQueryOptions<TPage, TPageParam, TError = unknown, TServices = never>(options: Omit<InfiniteQueryOptions<TPage, TPageParam, TError, TServices>, "kind">): InfiniteQueryOptions<TPage, TPageParam, TError, TServices>;
+export declare function queryOptions<TData, TError = unknown, TServices = never>(options: Omit<QueryOptions<{
+  data: TData;
+  error: TError;
+  services: TServices;
+}>, "kind">): QueryOptions<{
+  data: TData;
+  error: TError;
+  services: TServices;
+}>;
+/**
+ * Typed options for a paged query factory. The page type is inferred from
+ * `queryFn`, as in {@link queryOptions}.
+ */
+export declare function infiniteQueryOptions<TPage, TPageParam, TError = unknown, TServices = never>(options: Omit<InfiniteQueryOptions<{
+  error: TError;
+  page: TPage;
+  pageParam: TPageParam;
+  services: TServices;
+}>, "kind">): InfiniteQueryOptions<{
+  error: TError;
+  page: TPage;
+  pageParam: TPageParam;
+  services: TServices;
+}>;
 interface FactoryResult {
   readonly kind: "infinite" | "query";
   readonly queryKey: QueryKey;
@@ -147,21 +224,27 @@ export type InputArgs<TFactory extends QueryFactory> = [] extends Parameters<TFa
 export type IsPaged<TFactory extends QueryFactory> = ReturnType<TFactory> extends {
   readonly kind: "infinite";
 } ? true : false;
-/** The data a factory's query resolves to. */
-export type DataOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TPage, infer TPageParam, infer _TError, infer _TServices> ? InfiniteData<TPage, TPageParam> : ReturnType<TFactory> extends QueryOptions<infer TData, infer _TError, infer _TServices> ? TData : never;
+/**
+ * The data a factory's query resolves to; `unknown` for a factory of no
+ * particular query.
+ */
+export type DataOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TTypes> ? InfiniteData<{
+  page: TTypes["page"];
+  pageParam: TTypes["pageParam"];
+}> : ReturnType<TFactory> extends QueryOptions<infer TTypes> ? TTypes["data"] : unknown;
 /**
  * The error a factory's request fails with: the `queryFn`'s Effect error
  * type, or `unknown` for promises and plain values.
  */
-export type ErrorOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer _TPage, infer _TPageParam, infer TError, infer _TServices> ? TError : ReturnType<TFactory> extends QueryOptions<infer _TData, infer TError, infer _TServices> ? TError : unknown;
+export type ErrorOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TTypes> ? ErrorIn<TTypes> : ReturnType<TFactory> extends QueryOptions<infer TTypes> ? ErrorIn<TTypes> : unknown;
 /**
  * The services a factory's `queryFn` Effect needs: what `ensure`, `fetch`,
  * `prefetch`, `getQuery` and `watch` require. `never` for promises and plain
  * values, and for a factory of no particular query.
  */
-export type ServicesOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer _TPage, infer _TPageParam, infer _TError, infer TServices> ? TServices : ReturnType<TFactory> extends QueryOptions<infer _TData, infer _TError, infer TServices> ? TServices : never;
+export type ServicesOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TTypes> ? ServicesIn<TTypes> : ReturnType<TFactory> extends QueryOptions<infer TTypes> ? ServicesIn<TTypes> : never;
 /** Page type of a paged factory. */
-export type PageOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TPage, unknown, infer _TError, infer _TServices> ? TPage : never;
+export type PageOf<TFactory extends QueryFactory> = ReturnType<TFactory> extends InfiniteQueryOptions<infer TTypes> ? TTypes["page"] : never;
 /** `ensure` / `fetch` options. Only paged factories accept `pages`. */
 export type LoadOptions<TFactory extends QueryFactory> = IsPaged<TFactory> extends true ? {
   /** Load this many pages up front (default 1). */

package/dist/options.mjs

@@ -13,6 +13,9 @@
 *
 * A `queryFn` Effect may need services; they're inferred, and every verb
 * that can start the query requires them.
+*
+* The type parameters are only there for TypeScript to infer the types bag
+* from `queryFn`; it can't infer a bag's members.
 */
 function queryOptions(options) {
 	return {
@@ -20,7 +23,10 @@ function queryOptions(options) {
 		kind: "query"
 	};
 }
-/** Typed options for a paged query factory. */
+/**
+* Typed options for a paged query factory. The page type is inferred from
+* `queryFn`, as in {@link queryOptions}.
+*/
 function infiniteQueryOptions(options) {
 	return {
 		...options,

package/dist/query.d.mts

@@ -5,11 +5,15 @@ import { CancelledError as CancelledError$1, TypeId as TypeId$1, entry_d_exports
 import { Direction } from "./infinite.mjs";
 import { Effect, Pipeable, Stream } from "effect";
 declare namespace query_d_exports {
-  export { CancelledError, FetchRequest, Of, Query, State, SubscribeOptions, TypeId, changes, fetch, fetchNextPage, fetchPreviousPage, get, getUnsafe, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isQuery, isStaleUnsafe, metaUnsafe, observerCountUnsafe, readUnsafe, refetch, reset, revalidateUnsafe, subscribeUnsafe };
+  export { CancelledError, FetchRequest, Query, State, SubscribeOptions, TypeId, changes, fetch, fetchNextPage, fetchPreviousPage, get, getUnsafe, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isQuery, isStaleUnsafe, metaUnsafe, observerCountUnsafe, readUnsafe, refetch, reset, revalidateUnsafe, subscribeUnsafe };
 }
 export declare const TypeId: typeof TypeId$1;
 export type TypeId = typeof TypeId;
-export interface Query<TData = unknown, TFactory extends QueryFactory = QueryFactory, TError = unknown> extends Pipeable.Pipeable {
+/**
+ * A cache entry, typed by the factory whose calls fill it: its data is the
+ * factory's {@link DataOf}, its error the factory's {@link ErrorOf}.
+ */
+export interface Query<TFactory extends QueryFactory = QueryFactory> extends Pipeable.Pipeable {
   /** The serializable handle for this entry's factory call. */
   readonly handle: QueryHandle<TFactory>;
   /** Stable string form of `key`. */
@@ -18,12 +22,10 @@ export interface Query<TData = unknown, TFactory extends QueryFactory = QueryFac
   /** Options from the latest factory call; `undefined` for an entry only hydrated so far. */
   readonly options: AnyQueryOptions | undefined;
   readonly [TypeId]: {
-    readonly _A: (_: never) => TData;
-    readonly _E: (_: never) => TError;
+    readonly _A: (_: never) => DataOf<TFactory>;
+    readonly _E: (_: never) => ErrorOf<TFactory>;
   };
 }
-/** The entry of a factory call, typed by the factory. */
-export type Of<TFactory extends QueryFactory> = Query<DataOf<TFactory>, TFactory, ErrorOf<TFactory>>;
 /** A snapshot of one cache entry. Replaced, never mutated, on every change. */
 export interface State<TData> {
   /** Last successful data, kept through background errors. */
@@ -73,54 +75,54 @@ export declare const isQuery: (value: unknown) => value is Query;
  * a `QueryCache` verb.
  */
 export declare const fetch: {
-  (request?: FetchRequest): <TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>) => Effect.Effect<TData, TError | CancelledError, ServicesOf<TFactory>>;
-  <TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>, request?: FetchRequest): Effect.Effect<TData, TError | CancelledError, ServicesOf<TFactory>>;
+  (request?: FetchRequest): <TFactory extends QueryFactory>(self: Query<TFactory>) => Effect.Effect<DataOf<TFactory>, ErrorOf<TFactory> | CancelledError, ServicesOf<TFactory>>;
+  <TFactory extends QueryFactory>(self: Query<TFactory>, request?: FetchRequest): Effect.Effect<DataOf<TFactory>, ErrorOf<TFactory> | CancelledError, ServicesOf<TFactory>>;
 };
 /** Refetch now; succeeds when the request settles, whatever its outcome. */
-export declare function refetch<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): Effect.Effect<void>;
+export declare function refetch<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<void>;
 /** Load the page after the last one; succeeds once it settles. */
-export declare function fetchNextPage<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): Effect.Effect<void>;
+export declare function fetchNextPage<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<void>;
 /** Load the page before the first one; succeeds once it settles. */
-export declare function fetchPreviousPage<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): Effect.Effect<void>;
+export declare function fetchPreviousPage<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<void>;
 /** Mark stale, and refetch if read; succeeds once that refetch settles. */
-export declare function invalidate<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): Effect.Effect<void>;
+export declare function invalidate<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<void>;
 /**
  * Drop data and errors, back to the state of a new entry. Readers suspend
  * and refetch; succeeds when that refetch settles.
  */
-export declare function reset<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): Effect.Effect<void>;
+export declare function reset<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<void>;
 /**
  * The query's `meta`: the latest factory call's (the one it was hydrated
  * with, before any), else the cache default's.
  */
-export declare function metaUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): QueryMeta | undefined;
+export declare function metaUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): QueryMeta | undefined;
 /** The entry's current state. */
-export declare function get<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): Effect.Effect<State<TData>>;
+export declare function get<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<State<DataOf<TFactory>>>;
 /** {@link get}, synchronously. */
-export declare function getUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): State<TData>;
+export declare function getUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): State<DataOf<TFactory>>;
 /**
  * The entry's current state, then every change. Counts as a reader while
  * the stream runs, so invalidation and focus refetch it.
  */
-export declare function changes<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): Stream.Stream<State<TData>>;
+export declare function changes<TFactory extends QueryFactory>(self: Query<TFactory>): Stream.Stream<State<DataOf<TFactory>>>;
 /**
  * The promise a render should unwrap. Starts the first request if nothing
  * has, and retries a failed first load once its error has been shown.
  */
-export declare function readUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): Thenable<TData>;
+export declare function readUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): Thenable<DataOf<TFactory>>;
 /**
  * Refetch cached data in the background if it's stale, as `prefetch` does
  * (on a server cache, only if invalidated). Does nothing without data or
  * while a request is in flight.
  */
-export declare function revalidateUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): void;
+export declare function revalidateUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): void;
 /** Listen for state changes. Subscribed entries count as read. */
-export declare function subscribeUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>, listener: () => void, options?: SubscribeOptions): () => void;
+export declare function subscribeUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>, listener: () => void, options?: SubscribeOptions): () => void;
 /** Staleness as of now; `state.isStale` is only kept current while read. */
-export declare function isStaleUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): boolean;
-export declare function hasNextPageUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): boolean;
-export declare function hasPreviousPageUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): boolean;
+export declare function isStaleUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): boolean;
+export declare function hasNextPageUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): boolean;
+export declare function hasPreviousPageUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): boolean;
 /** Readers currently subscribed. */
-export declare function observerCountUnsafe<TData, TFactory extends QueryFactory, TError>(self: Query<TData, TFactory, TError>): number;
+export declare function observerCountUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): number;
 //#endregion
 export { query_d_exports };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raf-query/core",
-  "version": "0.4.5",
+  "version": "0.5.1",
   "description": "Framework-agnostic core of raf-query, a render-as-you-fetch query library",
   "keywords": [
     "query",