@raf-query/core 0.11.1 → 0.13.0

package/dist/all-keyed.mjs

@@ -1,19 +0,0 @@
-//#region src/all-keyed.ts
-/**
-* Ponyfill of the TC39 `Promise.allKeyed` proposal: a record of promises in,
-* a promise of the same record out, rejecting on the first failure.
-*
-* ```ts
-* const data = await allKeyed({
-*   post: qc.ensure(postQuery, { slug }),
-*   author: qc.ensure(authorQuery, { slug }),
-* });
-* ```
-*/
-async function allKeyed(record) {
-	const keys = Object.keys(record);
-	const values = await Promise.all(keys.map((key) => record[key]));
-	return Object.fromEntries(keys.map((key, index) => [key, values[index]]));
-}
-//#endregion
-export { allKeyed };

package/dist/binding.d.mts

@@ -1,92 +0,0 @@
-import { QueryFactory, QueryHandle } from "./options.mjs";
-import { Query, query_d_exports } from "./query.mjs";
-import { QueryClient } from "./client.mjs";
-import { Options, QueryObserver, observer_d_exports } from "./observer.mjs";
-import { ReadValue, UseQueryControls, UseQueryOptions, UseQueryThrowOptions } from "./controls.mjs";
-declare namespace binding_d_exports {
-  export { Hooks, QueryBinding, ReadOptions, Result, ResultWithData, Source, makeUnsafe, observerOptions, queryFor, subscribeUnsafe, syncUnsafe };
-}
-/** A read's options: the observer's, and `throwOnError` for typed errors. */
-export type ReadOptions<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = UseQueryOptions & UseQueryThrowOptions<TFactory> & {
-  readonly throwOnError?: TThrow;
-};
-/**
- * What a binding's `useQuery` returns: the query's controls, the `promise`
- * of the data to show, and that `data` once it's there. Each property is a
- * getter that calls {@link Hooks.track}, so destructuring reads it once.
- */
-export type Result<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = UseQueryControls<TFactory> & {
-  /** The promise's data once it has settled, else `undefined`. */
-  readonly data: ReadValue<TFactory, TThrow> | undefined;
-  /**
-   * Settles with the data to show. A new promise per data version, already
-   * settled once the cache has data.
-   */
-  readonly promise: Promise<ReadValue<TFactory, TThrow>>;
-};
-/** {@link Result} for a handle from `ensure` or `fetch`. */
-export type ResultWithData<TFactory extends QueryFactory, TThrow extends boolean | undefined = undefined> = Result<TFactory, TThrow> & {
-  /** The query's data. The handle's `data` until the cache has data again. */
-  readonly data: ReadValue<TFactory, TThrow>;
-};
-/** How a framework plugs into a binding. */
-export interface Hooks {
-  /**
-   * Runs when the result changed: a property something read, or a pending
-   * promise something read settling in place. Typically bumps the version.
-   */
-  readonly notify: () => void;
-  /**
-   * Runs on every read of the result, before the read, so the framework
-   * re-runs whatever read it after {@link Hooks.notify}. Typically reads a
-   * version signal.
-   */
-  readonly track: () => void;
-  /**
-   * Runs cache writes (starting a read can notify observers synchronously)
-   * outside the framework's tracking. Default: runs `f` as is.
-   */
-  readonly untracked?: <A>(f: () => A) => A;
-}
-/** Where a binding reads its handle and options from. */
-export interface Source<TFactory extends QueryFactory> {
-  readonly handle: () => QueryHandle<TFactory>;
-  readonly options: () => UseQueryOptions & {
-    readonly throwOnError?: boolean;
-  };
-}
-/** One component's read of a query. */
-export interface QueryBinding<TFactory extends QueryFactory = QueryFactory> {
-  readonly client: QueryClient<unknown>;
-  readonly observer: QueryObserver<TFactory>;
-  /** The result, the same object for the binding's life. */
-  readonly result: Result<TFactory, boolean>;
-}
-/**
- * The query a handle points at. Calls the factory, so callers keep it for
- * as long as the handle is the same.
- */
-export declare function queryFor<TFactory extends QueryFactory>(client: QueryClient<unknown>, factory: TFactory, handle: QueryHandle<TFactory>): Query<TFactory>;
-/** The observer's part of a read's options. */
-export declare function observerOptions(options: UseQueryOptions): Options;
-/**
- * Bind `factory` to the handle and options `source` returns. Reads the
- * query and observes it, but doesn't subscribe: call {@link subscribeUnsafe}
- * where the framework mounts, in the browser.
- */
-export declare function makeUnsafe<TFactory extends QueryFactory>(client: QueryClient<unknown>, factory: TFactory, source: Source<TFactory>, hooks: Hooks): QueryBinding<TFactory>;
-/**
- * Follow the source: switch to a new handle's query, or new options. Reads
- * call it themselves, so markup that reads before the framework's effects
- * run still sees the new query. Bindings also call it from an effect, so a
- * new handle is observed even when nothing reads the result.
- */
-export declare function syncUnsafe<TFactory extends QueryFactory>(self: QueryBinding<TFactory>): void;
-/**
- * Notify {@link Hooks.notify} on result changes from now on. A server
- * render reads once and never unmounts, so bindings call it in the browser
- * only. Returns the unsubscribe.
- */
-export declare function subscribeUnsafe<TFactory extends QueryFactory>(self: QueryBinding<TFactory>): () => void;
-//#endregion
-export { binding_d_exports };

package/dist/binding.mjs

@@ -1,186 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { hashKey } from "./key.mjs";
-import { readUnsafe } from "./query.mjs";
-import { promiseControls, resultThenable, throwsOnError } from "./controls.mjs";
-import { getOptimisticResultUnsafe, getUnsafe, makeUnsafe as makeUnsafe$1, setOptionsUnsafe, subscribeUnsafe as subscribeUnsafe$1, trackProp } from "./observer.mjs";
-import { Result } from "effect";
-//#region src/binding.ts
-/**
-* What a framework's `useQuery` does, without the framework: one observer
-* per component, following the handle and options it reads through
-* getters, and a result of getters over the observer. A binding supplies
-* {@link Hooks}: how a read is tracked, how a change is announced, and how
-* cache writes run outside the framework's tracking. The Vue and Svelte
-* packages are this plus their reactivity and lifecycle.
-*
-* Synchronous throughout, for renders.
-*/
-var binding_exports = /* @__PURE__ */ __exportAll({
-	makeUnsafe: () => makeUnsafe,
-	observerOptions: () => observerOptions,
-	queryFor: () => queryFor,
-	subscribeUnsafe: () => subscribeUnsafe,
-	syncUnsafe: () => syncUnsafe
-});
-/**
-* The query a handle points at. Calls the factory, so callers keep it for
-* as long as the handle is the same.
-*/
-function queryFor(client, factory, handle) {
-	const args = [handle.input];
-	return client.getQuery(factory, ...args);
-}
-/** The observer's part of a read's options. */
-function observerOptions(options) {
-	return {
-		refetchInterval: options.refetchInterval,
-		refetchOnReconnect: options.refetchOnReconnect,
-		refetchOnWindowFocus: options.refetchOnWindowFocus,
-		whilePending: options.whilePending
-	};
-}
-function sameObserverOptions(a, b) {
-	return a.refetchInterval === b.refetchInterval && a.refetchOnReconnect === b.refetchOnReconnect && a.refetchOnWindowFocus === b.refetchOnWindowFocus && a.whilePending === b.whilePending;
-}
-function stateOf(self) {
-	return self;
-}
-const runNow = (f) => f();
-/**
-* Bind `factory` to the handle and options `source` returns. Reads the
-* query and observes it, but doesn't subscribe: call {@link subscribeUnsafe}
-* where the framework mounts, in the browser.
-*/
-function makeUnsafe(client, factory, source, hooks) {
-	return (hooks.untracked ?? runNow)(() => {
-		const handle = source.handle();
-		const query = queryFor(client, factory, handle);
-		const options = observerOptions(source.options());
-		readUnsafe(query);
-		const state = {
-			awaited: /* @__PURE__ */ new WeakSet(),
-			client,
-			factory,
-			handle,
-			hooks,
-			observer: makeUnsafe$1(query, options),
-			options,
-			query,
-			source
-		};
-		return Object.assign(state, { result: resultOf(state) });
-	});
-}
-/**
-* Follow the source: switch to a new handle's query, or new options. Reads
-* call it themselves, so markup that reads before the framework's effects
-* run still sees the new query. Bindings also call it from an effect, so a
-* new handle is observed even when nothing reads the result.
-*/
-function syncUnsafe(self) {
-	sync(stateOf(self));
-}
-function sync(impl) {
-	const handle = impl.source.handle();
-	const options = observerOptions(impl.source.options());
-	const newQuery = handle !== impl.handle && hashKey(handle.key) !== impl.query.hash;
-	impl.handle = handle;
-	if (!newQuery && sameObserverOptions(options, impl.options)) return;
-	(impl.hooks.untracked ?? runNow)(() => {
-		if (newQuery) {
-			impl.query = queryFor(impl.client, impl.factory, handle);
-			readUnsafe(impl.query);
-		}
-		impl.options = options;
-		setOptionsUnsafe(impl.observer, impl.query, options);
-	});
-}
-/**
-* Notify {@link Hooks.notify} on result changes from now on. A server
-* render reads once and never unmounts, so bindings call it in the browser
-* only. Returns the unsubscribe.
-*/
-function subscribeUnsafe(self) {
-	const impl = stateOf(self);
-	return subscribeUnsafe$1(impl.observer, impl.hooks.notify);
-}
-function resultOf(impl) {
-	const { hooks, observer } = impl;
-	function read(name) {
-		sync(impl);
-		hooks.track();
-		trackProp(observer, name);
-		return impl.client.isServer ? getOptimisticResultUnsafe(observer, impl.query, impl.options) : getUnsafe(observer);
-	}
-	function throwOnError() {
-		return throwsOnError(impl.query, impl.source.options().throwOnError, impl.client.throwOnError);
-	}
-	function shown() {
-		const promise = read("promise").promise;
-		if (promise.status === "pending" && !impl.awaited.has(promise)) {
-			impl.awaited.add(promise);
-			promise.then(hooks.notify, hooks.notify);
-		}
-		return throwOnError() ? promise : resultThenable(promise);
-	}
-	function controls() {
-		return promiseControls(getUnsafe(observer));
-	}
-	return {
-		get data() {
-			const promise = shown();
-			if (promise.status === "fulfilled") return promise.value;
-			const handle = impl.handle;
-			if (!("data" in handle)) return;
-			const data = handle.data;
-			return throwOnError() ? data : Result.succeed(data);
-		},
-		get error() {
-			return read("error").error;
-		},
-		fetchNextPage: () => controls().fetchNextPage(),
-		fetchPreviousPage: () => controls().fetchPreviousPage(),
-		get hash() {
-			return read("hash").hash;
-		},
-		get hasNextPage() {
-			return read("hasNextPage").hasNextPage;
-		},
-		get hasPreviousPage() {
-			return read("hasPreviousPage").hasPreviousPage;
-		},
-		get input() {
-			return read("input").input;
-		},
-		get isFetching() {
-			return read("isFetching").isFetching;
-		},
-		get isFetchingNextPage() {
-			return read("isFetchingNextPage").isFetchingNextPage;
-		},
-		get isFetchingPreviousPage() {
-			return read("isFetchingPreviousPage").isFetchingPreviousPage;
-		},
-		get isPending() {
-			return read("isPending").isPending;
-		},
-		get isPrevious() {
-			return read("isPrevious").isPrevious;
-		},
-		get isStale() {
-			return read("isStale").isStale;
-		},
-		get key() {
-			return read("key").key;
-		},
-		get promise() {
-			return shown();
-		},
-		refetch: () => controls().refetch(),
-		get updatedAt() {
-			return read("updatedAt").updatedAt;
-		}
-	};
-}
-//#endregion
-export { binding_exports, makeUnsafe, observerOptions, queryFor, subscribeUnsafe, syncUnsafe };

package/dist/cache.d.mts

@@ -1,164 +0,0 @@
-import { QueryKey } from "./key.mjs";
-import { DataOf, ErrorOf, InputArgs, InputOf, LoadOptions, PagedQueryFactory, QueryBehavior, QueryFactory, QueryHandle, QueryHandleWithData, ServicesOf } from "./options.mjs";
-import { CancelledError, Query, State, query_d_exports } from "./query.mjs";
-import { DehydrateOptions, DehydratedState, DehydratedStream, HydrateOptions } from "./hydration.mjs";
-import { Context, Effect, Layer, Option, Scope, Stream } from "effect";
-declare namespace cache_d_exports {
-  export { Config, Event, Filter, QueryCache, Target, TypeId, Updater, isQueryCache, layer, make };
-}
-export declare const TypeId = "~@raf-query/core/QueryCache";
-export type TypeId = typeof TypeId;
-export interface Config {
-  /** Defaults for every query; a factory's own options win. */
-  readonly defaults?: QueryBehavior;
-  /**
-   * Whether this cache runs on the server. Default: the {@link Platform}'s.
-   * Server caches don't retry, never garbage-collect, skip stale timers, and
-   * reuse cached data in `prefetch` / `ensure` / `fetch` instead of
-   * revalidating it, unless `invalidate` marked it.
-   */
-  readonly isServer?: boolean;
-}
-/** Emitted on {@link QueryCache.events} for every cache change. */
-export type Event = {
-  readonly query: Query;
-  /** `observers`: a reader subscribed or unsubscribed. */
-  readonly type: "added" | "observers" | "removed" | "updated";
-} | {
-  /** A request failed (after retries), with this error. */
-  readonly error: unknown;
-  readonly query: Query;
-  readonly type: "failed";
-};
-/**
- * Selects cache entries: by key prefix (exact key with `exact`), then by
- * `predicate`. Without `queryKey` every key matches, so `{}` selects the
- * whole cache.
- */
-export interface Filter {
-  readonly exact?: boolean;
-  /**
-   * Keep only entries this returns `true` for; runs after key matching.
-   * `query.handle.input` is the input of the latest factory call, and stays
-   * `undefined` for an entry only hydrated so far; match on `query.key` to
-   * include those.
-   */
-  readonly predicate?: (query: Query) => boolean;
-  readonly queryKey?: QueryKey;
-}
-/** The entries `invalidate`, `reset` and `remove` act on: one factory call, or a filter. */
-export type Target<TFactory extends QueryFactory> = [factory: TFactory, ...args: InputArgs<TFactory>] | [filter: Filter];
-/**
- * A new value, or a function of the current one. `previous` is `undefined`
- * both with no data and with `undefined` data.
- */
-export type Updater<TData> = TData | ((previous: TData | undefined) => TData);
-type Loaded<TFactory extends QueryFactory> = Effect.Effect<QueryHandleWithData<TFactory>, ErrorOf<TFactory> | CancelledError, ServicesOf<TFactory>>;
-export interface QueryCache {
-  /** Every entry. */
-  readonly all: Effect.Effect<ReadonlyArray<Query>>;
-  /** Drop every entry and interrupt their requests. */
-  readonly clear: Effect.Effect<void>;
-  /** Snapshot the cache for transfer to another cache (server → browser). */
-  dehydrate(options?: DehydrateOptions): Effect.Effect<DehydratedState>;
-  /**
-   * Snapshot the cache, then stream entries as they start or settle, each
-   * entry once. Entries that change in the same tick share a batch, which
-   * is sent a microtask later. `updates` ends when the scope closes, after
-   * sending what changed before; `hydrateStream` is the receiving end.
-   */
-  dehydrateStream(options?: DehydrateOptions): Effect.Effect<DehydratedStream, never, Scope.Scope>;
-  /**
-   * {@link fetch} without waiting on stale data: start a query and wait for
-   * it on a cache miss. Stale cached data succeeds immediately and
-   * revalidates in the browser. Fails if that request fails.
-   */
-  ensure<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Loaded<TFactory>;
-  /** {@link ensure}, loading `options.pages` pages of a paged query. */
-  ensure<TFactory extends PagedQueryFactory>(factory: TFactory, input: InputOf<TFactory>, options: LoadOptions): Loaded<TFactory>;
-  /** Cache events from the moment the stream starts. */
-  readonly events: Stream.Stream<Event>;
-  /**
-   * Start a query and succeed with a handle holding its data. Waits on a
-   * cache miss and on stale data (on the server, only invalidated data), so
-   * the data is fresh. Fails if that request fails.
-   */
-  fetch<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Loaded<TFactory>;
-  /** {@link fetch}, loading `options.pages` pages of a paged query. */
-  fetch<TFactory extends PagedQueryFactory>(factory: TFactory, input: InputOf<TFactory>, options: LoadOptions): Loaded<TFactory>;
-  /**
-   * Cached data for a factory call. `Some(undefined)` when the data itself
-   * is `undefined`.
-   */
-  getData<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Effect.Effect<Option.Option<DataOf<TFactory>>>;
-  /**
-   * The cache entry for a factory call, created if missing. Doesn't fetch,
-   * 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<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>): Query<TFactory>;
-  /**
-   * Write dehydrated entries. Existing entries only take newer data; pending
-   * entries resume the sender's request.
-   */
-  hydrate(state: DehydratedState, options?: HydrateOptions): Effect.Effect<void>;
-  /** `hydrate` every state of a stream as it arrives (`dehydrateStream`'s `updates`). */
-  hydrateStream<E, R>(states: Stream.Stream<DehydratedState, E, R>, options?: HydrateOptions): Effect.Effect<void, E, R>;
-  /**
-   * Mark queries stale and refetch the ones being read. Succeeds once those
-   * refetches settle, so an action stays pending until fresh data is on
-   * screen.
-   */
-  invalidate<TFactory extends QueryFactory>(...target: Target<TFactory>): Effect.Effect<void>;
-  /**
-   * How many entries have a request in flight: all of them, or those
-   * matching `filter`. For global loading indicators.
-   */
-  isFetching(filter?: Filter): Effect.Effect<number>;
-  /** `isFetching`, synchronously, for renders. */
-  isFetchingUnsafe(filter?: Filter): number;
-  readonly isServer: boolean;
-  /**
-   * Refetch read, stale queries on window focus and reconnect while the
-   * scope is open. Mounts share one platform subscription. Does nothing on
-   * the server.
-   */
-  readonly mount: Effect.Effect<void, never, Scope.Scope>;
-  /**
-   * Start a query without waiting and return its handle. Fresh data is
-   * reused; stale data refetches in the background (in the browser only, see
-   * {@link Config.isServer}). Errors surface where the data is read, never
-   * here.
-   */
-  prefetch<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Effect.Effect<QueryHandle<TFactory>, never, ServicesOf<TFactory>>;
-  /**
-   * Remove queries from the cache and interrupt their requests. Readers keep
-   * the removed entry until they render again.
-   */
-  remove<TFactory extends QueryFactory>(...target: Target<TFactory>): Effect.Effect<void>;
-  /**
-   * Drop queries' data and errors, as if they were never fetched. Read ones
-   * suspend and refetch; succeeds once those refetches settle.
-   */
-  reset<TFactory extends QueryFactory>(...target: Target<TFactory>): Effect.Effect<void>;
-  /** Write data for a factory call. Readers re-render without suspending. */
-  setData<TFactory extends QueryFactory>(factory: TFactory, input: InputOf<TFactory>, updater: Updater<DataOf<TFactory>>): Effect.Effect<void>;
-  /** Listen to cache events synchronously, as they happen. */
-  subscribeUnsafe(listener: (event: Event) => void): () => void;
-  readonly [TypeId]: TypeId;
-  /** A factory call's `Query.changes`. */
-  watch<TFactory extends QueryFactory>(factory: TFactory, ...args: InputArgs<TFactory>): Stream.Stream<State<DataOf<TFactory>>, never, ServicesOf<TFactory>>;
-}
-export declare const QueryCache: Context.Service<QueryCache, QueryCache>;
-export declare function isQueryCache(value: unknown): value is QueryCache;
-/** Build a cache in the current scope, with the current `Clock` and {@link Platform}. */
-export declare const make: (config?: Config) => Effect.Effect<QueryCache, never, Scope.Scope>;
-/** A layer that provides a {@link QueryCache} for the layer's lifetime. */
-export declare const layer: (config?: Config) => Layer.Layer<QueryCache>;
-//#endregion
-export { cache_d_exports };

package/dist/cache.mjs

@@ -1,184 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { hashKey, matchesKey } from "./key.mjs";
-import { listen } from "./listen.mjs";
-import { Platform } from "./platform.mjs";
-import { changes, emit, fetch, invalidate, isObserved, make as make$1, needsRefetch, onPlatformEvent, provide, remove, reset, revalidate, setData, setOptions, start } from "./entry.mjs";
-import { dehydrateEntries, dehydrateStream, hydrateEntries } from "./hydration.mjs";
-import { optionsFor } from "./options.mjs";
-import { Clock, Context, Effect, Layer, Option, Predicate, RcRef, Stream } from "effect";
-//#region src/cache.ts
-/**
-* The query cache, as an Effect service. `make` builds one in the current
-* scope; closing the scope interrupts every request and timer it started.
-* Everything that waits, or changes the cache, is an Effect; `getQueryUnsafe`,
-* `isFetchingUnsafe` and `subscribeUnsafe` are for renders and external
-* stores.
-*
-* Requests run with the services the cache was built with, under those of
-* the latest verb that called for the entry. So the verbs that can start a
-* request (`ensure`, `fetch`, `prefetch`, `getQuery`, `watch`) require the
-* factory's {@link ServicesOf}; requests a render, a refetch or `invalidate`
-* starts reuse the entry's last services.
-*/
-var cache_exports = /* @__PURE__ */ __exportAll({
-	QueryCache: () => QueryCache,
-	TypeId: () => TypeId,
-	isQueryCache: () => isQueryCache,
-	layer: () => layer,
-	make: () => make
-});
-const TypeId = "~@raf-query/core/QueryCache";
-const QueryCache = /*#__PURE__*/ Context.Service(TypeId);
-function isQueryCache(value) {
-	return Predicate.hasProperty(value, TypeId);
-}
-function isUpdateFunction(updater) {
-	return Predicate.isFunction(updater);
-}
-function typed(entry) {
-	return entry;
-}
-function handleOf(entry) {
-	return entry.handle;
-}
-function dataOf(entry) {
-	return entry.state.data;
-}
-function keyMatcher(filter) {
-	const prefix = filter.queryKey;
-	if (prefix === void 0) return () => true;
-	if (filter.exact) {
-		const hash = hashKey(prefix);
-		return (entry) => entry.hash === hash;
-	}
-	return (entry) => matchesKey(entry.key, prefix);
-}
-/**
-* Waits for an entry's data on a cache miss, and with `fresh` also while it
-* needs a refetch (see `Entry.needsRefetch`). Otherwise cached data returns at
-* once, and revalidates in the background.
-*/
-function load(entry, pages, fresh) {
-	if (!entry.state.hasData || fresh && needsRefetch(entry)) return fetch(entry, { pages });
-	revalidate(entry);
-	return Effect.succeed(dataOf(entry));
-}
-/** The entry's handle as of this call, with the data `loaded` succeeds with. */
-function withData(entry, loaded) {
-	const handle = handleOf(entry);
-	return Effect.map(loaded, (data) => ({
-		...handle,
-		data
-	}));
-}
-/** Settles every effect, started together. */
-function settleAll(effects) {
-	return Effect.all(effects, {
-		concurrency: "unbounded",
-		discard: true
-	});
-}
-/** Build a cache in the current scope, with the current `Clock` and {@link Platform}. */
-const make = /*#__PURE__*/ Effect.fnUntraced(function* (config = {}) {
-	const platform = yield* Platform;
-	const state = {
-		clock: yield* Clock.Clock,
-		defaults: config.defaults ?? {},
-		entries: /* @__PURE__ */ new Map(),
-		isServer: config.isServer ?? platform.isServer,
-		listeners: /* @__PURE__ */ new Set(),
-		platform,
-		scope: yield* Effect.scope,
-		services: yield* Effect.context()
-	};
-	const entryFor = (key) => {
-		const hash = hashKey(key);
-		const existing = state.entries.get(hash);
-		if (existing) return existing;
-		const entry = make$1(state, key, hash);
-		state.entries.set(hash, entry);
-		emit(state, {
-			query: entry,
-			type: "added"
-		});
-		return entry;
-	};
-	const build = (factory, input) => {
-		const options = optionsFor(factory, input);
-		const entry = entryFor(options.queryKey);
-		setOptions(entry, options, input);
-		return entry;
-	};
-	/** `build`, for a verb: the entry's requests get the caller's services. */
-	const buildFor = (factory, input) => Effect.contextWith((caller) => {
-		const entry = build(factory, input);
-		provide(entry, caller);
-		return Effect.succeed(entry);
-	});
-	const match = (target) => {
-		const [first, input] = target;
-		if (Predicate.isFunction(first)) {
-			const entry = state.entries.get(hashKey(optionsFor(first, input).queryKey));
-			return entry ? [entry] : [];
-		}
-		const keyMatches = keyMatcher(first);
-		return [...state.entries.values()].filter((entry) => keyMatches(entry) && (first.predicate?.(entry) ?? true));
-	};
-	const subscription = yield* RcRef.make({ acquire: Effect.acquireRelease(Effect.sync(() => platform.subscribeUnsafe((event) => {
-		for (const entry of state.entries.values()) if (isObserved(entry)) onPlatformEvent(entry, event);
-	})), (unsubscribe) => Effect.sync(unsubscribe)) });
-	const subscribeUnsafe = (listener) => {
-		state.listeners.add(listener);
-		return () => {
-			state.listeners.delete(listener);
-		};
-	};
-	const getQueryUnsafe = (factory, ...args) => typed(build(factory, args[0]));
-	const isFetchingUnsafe = (filter) => (filter ? match([filter]) : [...state.entries.values()]).filter((entry) => entry.state.isFetching).length;
-	return {
-		all: Effect.sync(() => [...state.entries.values()]),
-		clear: Effect.sync(() => {
-			for (const entry of state.entries.values()) remove(entry);
-		}),
-		dehydrate: (options = {}) => Effect.sync(() => dehydrateEntries(state.entries.values(), options)),
-		dehydrateStream: (options = {}) => dehydrateStream(() => state.entries.values(), subscribeUnsafe, options),
-		ensure: (factory, input, options) => Effect.flatMap(buildFor(factory, input), (entry) => withData(entry, load(entry, options?.pages, false))),
-		events: listen(subscribeUnsafe),
-		fetch: (factory, input, options) => Effect.flatMap(buildFor(factory, input), (entry) => withData(entry, load(entry, options?.pages, true))),
-		getData: (factory, ...args) => Effect.sync(() => {
-			const options = optionsFor(factory, args[0]);
-			const entry = state.entries.get(hashKey(options.queryKey));
-			return entry?.state.hasData ? Option.some(dataOf(entry)) : Option.none();
-		}),
-		getQuery: (factory, ...args) => Effect.map(buildFor(factory, args[0]), typed),
-		getQueryUnsafe,
-		hydrate: (dehydrated, options = {}) => Effect.sync(() => hydrateEntries(entryFor, dehydrated, options)),
-		hydrateStream: (states, options = {}) => Stream.runForEach(states, (dehydrated) => Effect.sync(() => hydrateEntries(entryFor, dehydrated, options))),
-		invalidate: (...target) => Effect.suspend(() => settleAll(match(target).map(invalidate))),
-		isFetching: (filter) => Effect.sync(() => isFetchingUnsafe(filter)),
-		isFetchingUnsafe,
-		isServer: state.isServer,
-		mount: state.isServer ? Effect.void : Effect.asVoid(RcRef.get(subscription)),
-		prefetch: (factory, ...args) => Effect.map(buildFor(factory, args[0]), (entry) => {
-			if (entry.state.hasData) revalidate(entry);
-			else start(entry);
-			return handleOf(entry);
-		}),
-		remove: (...target) => Effect.sync(() => {
-			for (const entry of match(target)) remove(entry);
-		}),
-		reset: (...target) => Effect.suspend(() => settleAll(match(target).map(reset))),
-		setData: (factory, input, updater) => Effect.sync(() => {
-			const entry = build(factory, input);
-			const next = isUpdateFunction(updater) ? updater(entry.state.hasData ? dataOf(entry) : void 0) : updater;
-			setData(entry, next);
-		}),
-		subscribeUnsafe,
-		[TypeId]: TypeId,
-		watch: (factory, ...args) => Stream.unwrap(Effect.map(buildFor(factory, args[0]), (entry) => changes(entry)))
-	};
-});
-/** A layer that provides a {@link QueryCache} for the layer's lifetime. */
-const layer = (config) => Layer.effect(QueryCache, make(config));
-//#endregion
-export { QueryCache, TypeId, cache_exports, isQueryCache, layer, make };