@raf-query/core 0.0.19 → 0.1.0

package/dist/entry.d.mts

@@ -0,0 +1,113 @@
+import { Platform, PlatformEvent } from "./platform.mjs";
+import { QueryKey } from "./key.mjs";
+import { AnyQueryOptions, QueryBehavior, QueryFactory, QueryHandle } from "./options.mjs";
+import { Event } from "./cache.mjs";
+import { Pending, Thenable } from "./thenable.mjs";
+import { FetchRequest, Query, State, SubscribeOptions } from "./query.mjs";
+import { Cause, Clock, Context, Deferred, Effect, Scope, Stream } from "effect";
+declare namespace entry_d_exports {
+  export { CacheState, CancelledError, Entry, TypeId, changes, emit, entryOf, fetch, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isObserved, isQuery, isStaleUnsafe, make, now, onPlatformEvent, provide, readUnsafe, remove, reset, resume, setData, setOptions, start, subscribeUnsafe };
+}
+export declare const TypeId = "~@raf-query/core/Query";
+declare const CancelledError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "CancelledError";
+} & Readonly<A>;
+/**
+ * The failure of a request that was interrupted rather than settled: its
+ * entry was removed or cleared, or an Effect `queryFn` was interrupted.
+ */
+export declare class CancelledError extends CancelledError_base {
+  readonly message = "The query was cancelled";
+}
+/**
+ * The state a cache shares with its entries. Entries are created
+ * synchronously (a render reads one), so they fork their fibers with the
+ * services and into the scope the cache was made with.
+ */
+export interface CacheState {
+  readonly clock: Clock.Clock;
+  readonly defaults: QueryBehavior;
+  readonly entries: Map<string, Entry>;
+  readonly isServer: boolean;
+  readonly listeners: Set<(event: Event) => void>;
+  readonly platform: Platform;
+  readonly scope: Scope.Scope;
+  readonly services: Context.Context<never>;
+}
+/** The background work of an entry, one fiber per kind. */
+type Task = "errorShown" | "gc" | "request" | "stale";
+interface Tasks {
+  cancel(task: Task): void;
+  fork(task: Task, effect: Effect.Effect<void>, options?: {
+    readonly onlyIfMissing?: boolean;
+  }): void;
+}
+interface Commands {
+  readonly fetchNextPage: Effect.Effect<void>;
+  readonly fetchPreviousPage: Effect.Effect<void>;
+  readonly refetch: Effect.Effect<void>;
+}
+/** A cache entry: a {@link Query} and the state behind it. */
+export interface Entry extends Query {
+  readonly cache: CacheState;
+  /** One Effect per command, so readers can compare them by identity. */
+  readonly commands: Commands;
+  /** A failed first load was shown; the next read retries it. */
+  errorShown: boolean;
+  handle: QueryHandle;
+  /** Awaited by every caller of the request in flight; outlives restarts. */
+  inFlight: Deferred.Deferred<unknown, unknown> | undefined;
+  readonly listeners: Map<() => void, SubscribeOptions>;
+  options: AnyQueryOptions | undefined;
+  /** The first load's promise, until it settles. */
+  pending: Pending<unknown> | undefined;
+  /** Open while the entry is cached; owns its fibers. */
+  readonly scope: Scope.Closeable;
+  /**
+   * What its requests run with: the cache's services, under those of the
+   * latest verb that called for this entry ({@link provide}).
+   */
+  services: Context.Context<never>;
+  state: State<unknown>;
+  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 emit(cache: CacheState, event: Event): void;
+export declare function make(cache: CacheState, key: QueryKey, hash: string): Entry;
+export declare function now(entry: Entry): number;
+/** Readers are subscribed; `invalidate` and focus refetch only what is read. */
+export declare function isObserved(entry: Entry): boolean;
+export declare function isStaleUnsafe(entry: Entry): boolean;
+export declare function hasNextPageUnsafe(entry: Entry): boolean;
+export declare function hasPreviousPageUnsafe(entry: Entry): boolean;
+export declare function subscribeUnsafe(entry: Entry, listener: () => void, options?: SubscribeOptions): () => void;
+export declare function changes(entry: Entry): Stream.Stream<State<unknown>>;
+/**
+ * Run this entry's requests with the services of `caller`, a verb's fiber
+ * context, over the cache's: every request from now on, including ones a
+ * render, a refetch or `invalidate` starts.
+ */
+export declare function provide(entry: Entry, caller: Context.Context<never>): void;
+/** Attach the options and input of the latest factory call. */
+export declare function setOptions(entry: Entry, options: AnyQueryOptions, input: unknown): void;
+/**
+ * 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(entry: Entry): Thenable<unknown>;
+/** Start a request unless one is in flight, without waiting for it. */
+export declare function start(entry: Entry): void;
+export declare function fetch(entry: Entry, request?: FetchRequest): Effect.Effect<unknown, unknown>;
+export declare function invalidate(entry: Entry): Effect.Effect<void>;
+export declare function reset(entry: Entry): Effect.Effect<void>;
+/** Write data directly, as if a request had returned it. */
+export declare function setData(entry: Entry, data: unknown, updatedAt?: number): void;
+/** Adopt a request started elsewhere (the server's, during hydration). */
+export declare function resume(entry: Entry, promise: PromiseLike<unknown>): void;
+/** Refetch a read, stale entry whose readers want it on this event. */
+export declare function onPlatformEvent(entry: Entry, event: PlatformEvent): void;
+/** Take `entry` out of its cache: interrupt its fibers and fail its awaiters. */
+export declare function remove(entry: Entry): void;
+//#endregion
+export { entry_d_exports };

package/dist/entry.mjs

@@ -0,0 +1,421 @@
+import { whenOnline } from "./platform.mjs";
+import { unsafeCast } from "./cast.mjs";
+import { fetchPages, isInfiniteData, nextPageParam, previousPageParam } from "./infinite.mjs";
+import { listen } from "./listen.mjs";
+import { scheduleNotify } from "./notify.mjs";
+import { fromQueryFn, requestServices, runRequest } from "./request.mjs";
+import { retrySchedule } from "./retry.mjs";
+import { replaceEqualDeep } from "./share.mjs";
+import { fulfilled, pending } from "./thenable.mjs";
+import { Cause, Data, Deferred, Effect, Exit, FiberMap, Pipeable, Predicate, Scope } from "effect";
+//#region src/entry.ts
+const TypeId = "~@raf-query/core/Query";
+/**
+* The failure of a request that was interrupted rather than settled: its
+* entry was removed or cleared, or an Effect `queryFn` was interrupted.
+*/
+var CancelledError = class extends Data.TaggedError("CancelledError") {
+	message = "The query was cancelled";
+};
+const Proto = {
+	...Pipeable.Prototype,
+	[TypeId]: {
+		_A: (value) => value,
+		_E: (value) => value
+	}
+};
+const defaultSubscribeOptions = {};
+function isQuery(value) {
+	return Predicate.hasProperty(value, TypeId);
+}
+function entryOf(query) {
+	return unsafeCast(query);
+}
+function emit(cache, event) {
+	for (const listener of cache.listeners) listener(event);
+}
+/** Fibers keyed by task: forking a task interrupts its previous fiber. */
+function makeTasks(cache, scope) {
+	const runSync = Effect.runSyncWith(cache.services);
+	const runFork = Effect.runForkWith(cache.services);
+	const fibers = runSync(FiberMap.make().pipe(Scope.provide(scope)));
+	const run = runSync(FiberMap.runtime(fibers)());
+	return {
+		cancel(task) {
+			if (FiberMap.hasUnsafe(fibers, task)) runFork(FiberMap.remove(fibers, task));
+		},
+		fork(task, effect, options) {
+			run(task, effect, options);
+		}
+	};
+}
+function make(cache, key, hash) {
+	const scope = Scope.forkUnsafe(cache.scope);
+	const first = pending();
+	const entry = Object.assign(Object.create(Proto), {
+		cache,
+		errorShown: false,
+		handle: {
+			input: void 0,
+			key
+		},
+		hash,
+		inFlight: void 0,
+		key,
+		listeners: /* @__PURE__ */ new Map(),
+		options: void 0,
+		pending: first,
+		scope,
+		services: cache.services,
+		state: {
+			data: void 0,
+			error: null,
+			failureCount: 0,
+			fetchDirection: void 0,
+			hasData: false,
+			isFetching: false,
+			isInvalidated: false,
+			isStale: true,
+			promise: first.promise,
+			status: "pending",
+			updatedAt: 0
+		},
+		tasks: makeTasks(cache, scope)
+	});
+	const commands = {
+		fetchNextPage: Effect.ignore(fetch(entry, { direction: "forward" })),
+		fetchPreviousPage: Effect.ignore(fetch(entry, { direction: "backward" })),
+		refetch: Effect.ignore(fetch(entry))
+	};
+	Object.assign(entry, { commands });
+	scheduleGc(entry);
+	return entry;
+}
+function now(entry) {
+	return entry.cache.clock.currentTimeMillisUnsafe();
+}
+/** Readers are subscribed; `invalidate` and focus refetch only what is read. */
+function isObserved(entry) {
+	return entry.listeners.size > 0;
+}
+function behavior(entry, name) {
+	return entry.options?.[name] ?? entry.cache.defaults[name];
+}
+function computeStale(entry, state) {
+	if (state.isInvalidated || !state.hasData) return true;
+	const staleTime = behavior(entry, "staleTime") ?? 0;
+	return now(entry) - state.updatedAt >= staleTime;
+}
+function isStaleUnsafe(entry) {
+	return computeStale(entry, entry.state);
+}
+function hasNextPageUnsafe(entry) {
+	const options = entry.options;
+	const data = entry.state.data;
+	return options?.kind === "infinite" && isInfiniteData(data) && nextPageParam(options, data) != null;
+}
+function hasPreviousPageUnsafe(entry) {
+	const options = entry.options;
+	const data = entry.state.data;
+	return options?.kind === "infinite" && isInfiniteData(data) && previousPageParam(options, data) != null;
+}
+function subscribeUnsafe(entry, listener, options = defaultSubscribeOptions) {
+	entry.listeners.set(listener, options);
+	entry.tasks.cancel("gc");
+	scheduleStale(entry);
+	emit(entry.cache, {
+		query: entry,
+		type: "observers"
+	});
+	return () => {
+		if (!entry.listeners.delete(listener)) return;
+		if (entry.listeners.size === 0) {
+			entry.tasks.cancel("stale");
+			scheduleGc(entry);
+		}
+		emit(entry.cache, {
+			query: entry,
+			type: "observers"
+		});
+	};
+}
+function changes(entry) {
+	return listen((push) => {
+		push(entry.state);
+		return subscribeUnsafe(entry, () => push(entry.state));
+	});
+}
+/**
+* Run this entry's requests with the services of `caller`, a verb's fiber
+* context, over the cache's: every request from now on, including ones a
+* render, a refetch or `invalidate` starts.
+*/
+function provide(entry, caller) {
+	entry.services = requestServices(entry.cache.services, caller);
+}
+/** Attach the options and input of the latest factory call. */
+function setOptions(entry, options, input) {
+	entry.options = options;
+	if (entry.handle.input !== input) entry.handle = {
+		input,
+		key: entry.key
+	};
+}
+/**
+* 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.
+*/
+function readUnsafe(entry) {
+	const state = entry.state;
+	if (!state.hasData && !state.isFetching) {
+		if (state.status !== "error" || entry.errorShown) begin(entry, {});
+		else markErrorShown(entry);
+	}
+	return entry.state.promise;
+}
+/** Start a request unless one is in flight, without waiting for it. */
+function start(entry) {
+	begin(entry, {});
+}
+function fetch(entry, request = {}) {
+	return Effect.suspend(() => {
+		const inFlight = entry.inFlight;
+		if (inFlight && request.direction && !request.restart) return Deferred.await(inFlight).pipe(Effect.exit, Effect.andThen(fetch(entry, request)));
+		return begin(entry, request);
+	});
+}
+function invalidate(entry) {
+	return Effect.suspend(() => {
+		set(entry, { isInvalidated: true });
+		if (!isObserved(entry) || !entry.options) return Effect.void;
+		return Effect.ignore(begin(entry, { restart: true }));
+	});
+}
+function reset(entry) {
+	return Effect.suspend(() => {
+		entry.tasks.cancel("errorShown");
+		entry.errorShown = false;
+		entry.pending ??= pending();
+		set(entry, {
+			data: void 0,
+			error: null,
+			failureCount: 0,
+			hasData: false,
+			isInvalidated: false,
+			promise: entry.pending.promise,
+			status: "pending",
+			updatedAt: 0
+		});
+		if (!entry.options || !isObserved(entry) && !entry.inFlight) return Effect.void;
+		return Effect.ignore(begin(entry, { restart: true }));
+	});
+}
+/** Write data directly, as if a request had returned it. */
+function setData(entry, data, updatedAt = now(entry)) {
+	succeed(entry, data, updatedAt);
+}
+/** Adopt a request started elsewhere (the server's, during hydration). */
+function resume(entry, promise) {
+	if (entry.state.hasData || entry.inFlight) return;
+	startRequest(entry, Effect.promise(() => Promise.resolve(promise)), void 0);
+}
+/** Refetch a read, stale entry whose readers want it on this event. */
+function onPlatformEvent(entry, event) {
+	const option = event === "focus" ? "refetchOnWindowFocus" : "refetchOnReconnect";
+	const fallback = behavior(entry, option) ?? true;
+	if ([...entry.listeners.values()].some((options) => options[option] ?? fallback) && isStaleUnsafe(entry)) start(entry);
+}
+/** Take `entry` out of its cache: interrupt its fibers and fail its awaiters. */
+function remove(entry) {
+	const cache = entry.cache;
+	if (cache.entries.get(entry.hash) !== entry) return;
+	cache.entries.delete(entry.hash);
+	const inFlight = entry.inFlight;
+	entry.inFlight = void 0;
+	Effect.runForkWith(cache.services)(Scope.close(entry.scope, Exit.void));
+	if (inFlight) Deferred.doneUnsafe(inFlight, Exit.fail(new CancelledError()));
+	emit(cache, {
+		query: entry,
+		type: "removed"
+	});
+}
+/**
+* Start a request now, or join the one in flight. The returned Effect
+* waits for its result.
+*/
+function begin(entry, request) {
+	if (Predicate.isTagged(entry.scope.state, "Closed")) return Effect.fail(new CancelledError());
+	const options = entry.options;
+	const inFlight = entry.inFlight;
+	if (inFlight && !(request.restart && options)) return Deferred.await(inFlight);
+	if (!options) {
+		const promise = entry.state.promise;
+		return Effect.promise(() => promise);
+	}
+	entry.tasks.cancel("request");
+	return Deferred.await(startRequest(entry, runRequest(requestEffect(entry, options, request), entry.hash, entry.services), request.direction));
+}
+function set(entry, patch) {
+	const next = {
+		...entry.state,
+		...patch
+	};
+	entry.state = {
+		...next,
+		isStale: computeStale(entry, next)
+	};
+	for (const listener of entry.listeners.keys()) scheduleNotify(listener);
+	emit(entry.cache, {
+		query: entry,
+		type: "updated"
+	});
+	scheduleStale(entry);
+}
+/** Run `request` as the entry's request fiber, settling into its awaiter. */
+function startRequest(entry, request, direction) {
+	const awaiter = entry.inFlight ?? Deferred.makeUnsafe();
+	entry.inFlight = awaiter;
+	entry.tasks.cancel("gc");
+	if (!entry.state.hasData && entry.state.status === "error") {
+		entry.pending = pending();
+		set(entry, {
+			error: null,
+			failureCount: 0,
+			fetchDirection: direction,
+			isFetching: true,
+			promise: entry.pending.promise,
+			status: "pending"
+		});
+	} else set(entry, {
+		failureCount: 0,
+		fetchDirection: direction,
+		isFetching: true
+	});
+	entry.tasks.fork("request", Effect.exit(request).pipe(Effect.flatMap((exit) => Effect.sync(() => settle(entry, awaiter, exit)))));
+	return awaiter;
+}
+function settle(entry, awaiter, exit) {
+	if (entry.inFlight !== awaiter) return;
+	entry.inFlight = void 0;
+	if (Exit.isSuccess(exit)) {
+		const data = succeed(entry, exit.value, now(entry));
+		Deferred.doneUnsafe(awaiter, Exit.succeed(data));
+	} else if (Cause.hasInterruptsOnly(exit.cause)) {
+		set(entry, {
+			fetchDirection: void 0,
+			isFetching: false
+		});
+		Deferred.doneUnsafe(awaiter, Exit.fail(new CancelledError()));
+	} else {
+		fail(entry, Cause.squash(exit.cause));
+		Deferred.doneUnsafe(awaiter, exit);
+	}
+	scheduleGc(entry);
+}
+function succeed(entry, next, updatedAt) {
+	const previous = entry.state;
+	const data = previous.hasData && behavior(entry, "structuralSharing") !== false ? replaceEqualDeep(previous.data, next) : next;
+	const firstLoad = entry.pending;
+	entry.pending = void 0;
+	firstLoad?.resolve(data);
+	const unchanged = previous.hasData && data === previous.data;
+	set(entry, {
+		data,
+		error: null,
+		failureCount: 0,
+		fetchDirection: void 0,
+		hasData: true,
+		isFetching: false,
+		isInvalidated: false,
+		promise: firstLoad?.promise ?? (unchanged ? previous.promise : fulfilled(data)),
+		status: "success",
+		updatedAt
+	});
+	return data;
+}
+function fail(entry, error) {
+	emit(entry.cache, {
+		error,
+		query: entry,
+		type: "failed"
+	});
+	if (!entry.state.hasData) {
+		const firstLoad = entry.pending;
+		entry.pending = void 0;
+		firstLoad?.reject(error);
+		entry.errorShown = false;
+	}
+	set(entry, {
+		error,
+		fetchDirection: void 0,
+		isFetching: false,
+		status: "error"
+	});
+}
+/**
+* A failed first load rejects its promise, so the reader throws to an error
+* boundary. Every read in that same task (React retries a throwing render
+* once, StrictMode renders twice) gets the rejection too; a read in a later
+* task — the boundary was reset — starts a new request.
+*/
+function markErrorShown(entry) {
+	entry.tasks.fork("errorShown", Effect.yieldNow.pipe(Effect.andThen(Effect.sync(() => {
+		entry.errorShown = true;
+	}))), { onlyIfMissing: true });
+}
+function requestEffect(entry, options, request) {
+	const queryKey = options.queryKey;
+	if (options.kind === "query") return attempt(entry, (signal) => options.queryFn({
+		queryKey,
+		signal
+	}));
+	const current = isInfiniteData(entry.state.data) ? entry.state.data : void 0;
+	return fetchPages(options, current, request, (pageParam, direction) => attempt(entry, (signal) => options.queryFn({
+		direction,
+		pageParam,
+		queryKey,
+		signal
+	})));
+}
+/**
+* One `queryFn` call, retried per the query's policy. Every failure counts.
+* Its services are erased with its data type; `runRequest` provides them.
+*/
+function attempt(entry, call) {
+	const once = fromQueryFn(call).pipe(Effect.tapError(() => Effect.sync(() => set(entry, { failureCount: entry.state.failureCount + 1 }))));
+	const schedule = retrySchedule({
+		retry: behavior(entry, "retry"),
+		retryDelay: behavior(entry, "retryDelay")
+	}, entry.cache.isServer);
+	if (!schedule) return once;
+	const online = entry.cache.isServer ? Effect.void : whenOnline;
+	return Effect.suspend(() => {
+		let retrying = false;
+		const gated = Effect.suspend(() => {
+			const wait = retrying ? online : Effect.void;
+			retrying = true;
+			return Effect.andThen(wait, once);
+		});
+		return Effect.retry(gated, schedule);
+	});
+}
+function scheduleGc(entry) {
+	const gcTime = behavior(entry, "gcTime") ?? (entry.cache.isServer ? Infinity : 3e5);
+	if (isObserved(entry) || entry.inFlight || !Number.isFinite(gcTime)) {
+		entry.tasks.cancel("gc");
+		return;
+	}
+	entry.tasks.fork("gc", Effect.sleep(gcTime).pipe(Effect.andThen(Effect.sync(() => remove(entry)))));
+}
+function scheduleStale(entry) {
+	const state = entry.state;
+	const staleTime = behavior(entry, "staleTime") ?? 0;
+	if (entry.cache.isServer || !isObserved(entry) || state.isStale || !Number.isFinite(staleTime)) {
+		entry.tasks.cancel("stale");
+		return;
+	}
+	const remaining = state.updatedAt + staleTime - now(entry);
+	entry.tasks.fork("stale", Effect.sleep(Math.max(remaining, 0) + 1).pipe(Effect.andThen(Effect.sync(() => set(entry, {})))));
+}
+//#endregion
+export { CancelledError, TypeId, changes, emit, entryOf, fetch, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isObserved, isQuery, isStaleUnsafe, make, now, onPlatformEvent, provide, readUnsafe, remove, reset, resume, setData, setOptions, start, subscribeUnsafe };

package/dist/hydration.d.mts

@@ -1,6 +1,9 @@
 import { QueryKey } from "./key.mjs";
-import { Query } from "./query.mjs";
-import { QueryClient } from "./client.mjs";
+import { QueryFactory } from "./options.mjs";
+import "./cache.mjs";
+import "./entry.mjs";
+import { Query, query_d_exports } from "./query.mjs";
+import { Cause, Effect, Scope, Stream } from "effect";
 //#region src/hydration.d.ts
 /**
  * One cache entry in transit. Settled entries carry `data`; entries still
@@ -17,6 +20,16 @@ export interface DehydratedQuery {
 export interface DehydratedState {
   readonly queries: ReadonlyArray<DehydratedQuery>;
 }
+/** The cache now, then entries as they start or settle. */
+export interface DehydratedStream {
+  /** The entries to send first. */
+  readonly initial: DehydratedState;
+  /**
+   * Later entries, in batches. Ends once the scope `dehydrateStream` ran in
+   * closes, after a last batch of what changed before. One consumer only.
+   */
+  readonly updates: Stream.Stream<DehydratedState>;
+}
 export interface DehydrateOptions {
   /**
    * Which entries to send. Default: entries with data or a request in
@@ -25,10 +38,16 @@ export interface DehydrateOptions {
   readonly filter?: (query: Query) => boolean;
   /**
    * Send a pending query's rejection as-is. By default the receiving side
-   * gets a generic error, so server errors don't leak into the page; its
-   * error boundary can still retry on the client.
+   * gets a {@link RedactedError}, so server errors don't leak into the page;
+   * its error boundary can still retry on the client.
    */
   readonly keepErrors?: boolean;
+  /**
+   * Hashes of entries sent already, shared by every dehydration of one
+   * transfer (e.g. one request). Those entries are skipped, and the ones
+   * sent are added.
+   */
+  readonly sent?: Set<string>;
   /** Transform data before it is serialized. */
   readonly serializeData?: (data: unknown) => unknown;
 }
@@ -36,15 +55,20 @@ export interface HydrateOptions {
   /** Reverse `serializeData`. */
   readonly deserializeData?: (data: unknown) => unknown;
 }
-/** The default dehydrate filter: entries with data or a request in flight. */
-export declare function canDehydrate(query: Query): boolean;
-/** Snapshot one entry for transfer. */
-export declare function dehydrateQuery(query: Query, options?: DehydrateOptions): DehydratedQuery;
-/** Snapshot the cache for transfer to another client (server → browser). */
-export declare function dehydrate(client: QueryClient, options?: DehydrateOptions): DehydratedState;
+declare const RedactedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => Cause.YieldableError & {
+  readonly _tag: "RedactedError";
+} & Readonly<A>;
 /**
- * Write dehydrated entries into a client. Existing entries only take newer
- * data; pending entries resume the sender's request.
+ * What a dehydrated pending query rejects with when its request failed and
+ * `keepErrors` is off: the receiving side learns which query failed, not why.
  */
-export declare function hydrate(client: QueryClient, state: DehydratedState, options?: HydrateOptions): void;
+export declare class RedactedError extends RedactedError_base<{
+  readonly hash: string;
+}> {
+  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;
+/** Snapshot one entry for transfer. */
+export declare function dehydrateQuery<TData, TFactory extends QueryFactory, TError>(query: Query<TData, TFactory, TError>, options?: DehydrateOptions): Effect.Effect<DehydratedQuery>;
 //#endregion