@raf-query/core 0.11.1 → 0.12.0

package/dist/observer.mjs

@@ -1,300 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { listen } from "./listen.mjs";
-import { Platform } from "./platform.mjs";
-import { entryOf } from "./entry.mjs";
-import { fetchNextPage, fetchPreviousPage, getUnsafe as getUnsafe$1, hasNextPageUnsafe, hasPreviousPageUnsafe, refetch, subscribeUnsafe as subscribeUnsafe$1 } from "./query.mjs";
-import { Effect, Exit, FiberHandle, Pipeable, Predicate, Scope } from "effect";
-//#region src/observer.ts
-/**
-* One reader's view of one query at a time, as a data type, like TanStack
-* Query's `QueryObserver`: it derives the reader's result from the query's
-* state, keeps a previous query's data for `whilePending: "previous"`, runs
-* `refetchInterval`, and notifies its listeners only when a result property
-* they read changed (see {@link trackResult}), or a promise whose `status`
-* they read settled (see {@link trackThenable}). Bindings make one per hook.
-*
-* The `*Unsafe` functions read and update synchronously, for renders and
-* external stores. While it has listeners, the observer holds a `Scope` (a
-* child of its query's) that owns the query subscription and the polling
-* fiber; the last listener leaving, a switch to another query, or the query
-* leaving its cache closes it.
-*/
-var observer_exports = /* @__PURE__ */ __exportAll({
-	TypeId: () => TypeId,
-	changes: () => changes,
-	get: () => get,
-	getOptimisticResultUnsafe: () => getOptimisticResultUnsafe,
-	getUnsafe: () => getUnsafe,
-	isQueryObserver: () => isQueryObserver,
-	make: () => make,
-	makeUnsafe: () => makeUnsafe,
-	setOptionsUnsafe: () => setOptionsUnsafe,
-	subscribeUnsafe: () => subscribeUnsafe,
-	trackProp: () => trackProp,
-	trackResult: () => trackResult,
-	trackThenable: () => trackThenable
-});
-const TypeId = "~@raf-query/core/QueryObserver";
-const Proto = {
-	...Pipeable.Prototype,
-	[TypeId]: { _A: (value) => value }
-};
-const resultKeys = {
-	error: true,
-	fetchNextPage: true,
-	fetchPreviousPage: true,
-	hash: true,
-	hasNextPage: true,
-	hasPreviousPage: true,
-	input: true,
-	isFetching: true,
-	isFetchingNextPage: true,
-	isFetchingPreviousPage: true,
-	isPending: true,
-	isPrevious: true,
-	isStale: true,
-	key: true,
-	promise: true,
-	refetch: true,
-	updatedAt: true
-};
-function isQueryObserver(value) {
-	return Predicate.hasProperty(value, TypeId);
-}
-function implOf(self) {
-	return self;
-}
-function isResultKey(name) {
-	return Predicate.isString(name) && Object.hasOwn(resultKeys, name);
-}
-/** Whether `next.promise` has a different status than it had in the current result. */
-function settled(self, next) {
-	return self.currentStatus !== next.promise.status;
-}
-function anyChanged(self, next) {
-	return settled(self, next) || Object.keys(resultKeys).some((name) => isResultKey(name) && self.current[name] !== next[name]);
-}
-function setCurrent(self, next) {
-	self.current = next;
-	self.currentStatus = next.promise.status;
-}
-/** The result for `query` with `options`, given the last query that had data. */
-function resultOf(query, options, lastWithData) {
-	const state = getUnsafe$1(query);
-	const previous = options.whilePending === "previous" && !state.hasData && state.status !== "error" && lastWithData !== void 0 && lastWithData.hash !== query.hash ? lastWithData : void 0;
-	const shown = previous ?? query;
-	const shownState = previous ? getUnsafe$1(previous) : state;
-	return {
-		error: state.error,
-		fetchNextPage: fetchNextPage(query),
-		fetchPreviousPage: fetchPreviousPage(query),
-		hash: query.hash,
-		hasNextPage: hasNextPageUnsafe(query),
-		hasPreviousPage: hasPreviousPageUnsafe(query),
-		input: shown.handle.input,
-		isFetching: state.isFetching,
-		isFetchingNextPage: state.fetchDirection === "forward",
-		isFetchingPreviousPage: state.fetchDirection === "backward",
-		isPending: !state.hasData,
-		isPrevious: previous !== void 0,
-		isStale: state.isStale,
-		key: shown.handle.key,
-		promise: shownState.promise,
-		refetch: refetch(query),
-		updatedAt: shownState.updatedAt
-	};
-}
-/** Observe `query`. Doesn't subscribe to it until the observer has a listener. */
-function makeUnsafe(query, options = {}) {
-	const current = resultOf(query, options, void 0);
-	return Object.assign(Object.create(Proto), {
-		current,
-		currentStatus: current.promise.status,
-		lastWithData: getUnsafe$1(query).hasData ? query : void 0,
-		listeners: /* @__PURE__ */ new Set(),
-		options,
-		query,
-		subscription: void 0,
-		tracked: void 0,
-		trackedProps: /* @__PURE__ */ new Set()
-	});
-}
-/** {@link makeUnsafe}, as an Effect. */
-function make(query, options) {
-	return Effect.sync(() => makeUnsafe(query, options));
-}
-/** The current result. */
-function getUnsafe(self) {
-	return implOf(self).current;
-}
-/** {@link getUnsafe}, as an Effect. */
-function get(self) {
-	return Effect.sync(() => getUnsafe(self));
-}
-/**
-* The result for `query` with `options` right now, without switching to
-* them. Bindings call this during render, before `setOptionsUnsafe` commits.
-*/
-function getOptimisticResultUnsafe(self, query, options) {
-	const impl = implOf(self);
-	const result = resultOf(query, options, impl.lastWithData);
-	if (anyChanged(impl, result)) setCurrent(impl, result);
-	return result;
-}
-/** Observe `query` with `options` from now on. */
-function setOptionsUnsafe(self, query, options) {
-	const impl = implOf(self);
-	const previous = impl.query;
-	const previousInterval = impl.options.refetchInterval;
-	impl.query = query;
-	impl.options = options;
-	if (impl.listeners.size > 0) {
-		if (query !== previous) connect(impl);
-		else if (options.refetchInterval !== previousInterval) restartPolling(impl);
-	}
-	updateResult(impl);
-}
-/** Listen for result changes. The first listener subscribes to the query. */
-function subscribeUnsafe(self, listener) {
-	const impl = implOf(self);
-	impl.listeners.add(listener);
-	if (!impl.subscription) {
-		connect(impl);
-		updateResult(impl);
-	}
-	return () => {
-		if (!impl.listeners.delete(listener) || impl.listeners.size > 0) return;
-		disconnect(impl);
-	};
-}
-/**
-* The current result, then every change listeners are notified of. Counts
-* as a listener while the stream runs, so the query counts as read.
-*/
-function changes(self) {
-	return listen((push) => {
-		let last;
-		const emit = () => {
-			const result = getUnsafe(self);
-			if (result !== last) {
-				last = result;
-				push(result);
-			}
-		};
-		const unsubscribe = subscribeUnsafe(self, emit);
-		emit();
-		return unsubscribe;
-	});
-}
-/**
-* Wrap `result` so that reading a property marks it tracked. Once any
-* property is tracked, listeners are only notified when a tracked one
-* changes.
-*/
-function trackResult(self, result) {
-	return new Proxy(result, { get: (target, name, receiver) => {
-		if (isResultKey(name)) trackProp(self, name);
-		return Reflect.get(target, name, receiver);
-	} });
-}
-const settledFields = /* @__PURE__ */ new Set([
-	"reason",
-	"status",
-	"value"
-]);
-/**
-* One wrapper per promise, shared by every observer, so its identity is as
-* stable as the promise's: an observer made by a render that suspended
-* before committing is replaced on the next attempt, and `use()` expects
-* the same promise again.
-*/
-const wrappers = /* @__PURE__ */ new WeakMap();
-/** Wrappers whose `status`, `value` or `reason` a reader has read. */
-const settledReads = /* @__PURE__ */ new WeakSet();
-/**
-* Wrap `promise`, the result's or one derived from it, so that reading its
-* `status`, `value` or `reason` marks its settling as tracked. A first load
-* settles its promise in place, without a new promise, so only readers of
-* those fields need to hear about it. The mark is the wrapper's, shared by
-* the observers that hand it out.
-*/
-function trackThenable(self, promise) {
-	let wrapper = wrappers.get(promise);
-	if (!wrapper) {
-		const created = new Proxy(promise, { get: (target, name) => {
-			if (settledFields.has(name)) settledReads.add(created);
-			const value = Reflect.get(target, name, target);
-			return Predicate.isFunction(value) ? value.bind(target) : value;
-		} });
-		wrappers.set(promise, created);
-		wrapper = created;
-	}
-	implOf(self).tracked = wrapper;
-	return wrapper;
-}
-function readsSettled(self) {
-	return self.tracked !== void 0 && settledReads.has(self.tracked);
-}
-/** Mark `name` as read, for bindings that track access themselves. */
-function trackProp(self, name) {
-	implOf(self).trackedProps.add(name);
-}
-/** Recompute the result, and notify listeners if a tracked property changed. */
-function updateResult(self) {
-	const next = resultOf(self.query, self.options, self.lastWithData);
-	if (getUnsafe$1(self.query).hasData) self.lastWithData = self.query;
-	if (!anyChanged(self, next)) return;
-	const notify = shouldNotify(self, next);
-	setCurrent(self, next);
-	if (notify) for (const listener of self.listeners) listener();
-}
-/** Whether something tracked differs in `next` from the current result. */
-function shouldNotify(self, next) {
-	if (self.trackedProps.size === 0 && !readsSettled(self)) return true;
-	if (readsSettled(self) && settled(self, next)) return true;
-	for (const name of self.trackedProps) if (self.current[name] !== next[name]) return true;
-	return false;
-}
-/**
-* Subscribe to the current query in a new scope under its entry's, and
-* start polling. Replaces any previous subscription.
-*/
-function connect(self) {
-	disconnect(self);
-	const query = self.query;
-	const preferences = {
-		get refetchOnReconnect() {
-			return self.options.refetchOnReconnect;
-		},
-		get refetchOnWindowFocus() {
-			return self.options.refetchOnWindowFocus;
-		}
-	};
-	const scope = Scope.forkUnsafe(entryOf(query).scope);
-	self.subscription = {
-		polls: Effect.runSync(FiberHandle.make().pipe(Effect.tap(Effect.acquireRelease(Effect.sync(() => subscribeUnsafe$1(query, () => updateResult(self), preferences)), (unsubscribe) => Effect.sync(unsubscribe))), Scope.provide(scope))),
-		scope
-	};
-	restartPolling(self);
-}
-function disconnect(self) {
-	const subscription = self.subscription;
-	self.subscription = void 0;
-	if (subscription) Effect.runFork(Scope.close(subscription.scope, Exit.void));
-}
-/** Run `poll` for the current `refetchInterval`, or stop polling without one. */
-function restartPolling(self) {
-	const subscription = self.subscription;
-	if (!subscription) return;
-	const interval = self.options.refetchInterval;
-	const polls = subscription.polls;
-	Effect.runForkWith(entryOf(self.query).cache.services)(interval !== void 0 && Number.isFinite(interval) && interval > 0 ? FiberHandle.run(polls, poll(self.query, interval)) : FiberHandle.clear(polls));
-}
-/** Refetch `query` every `interval` ms while the page is visible. */
-function poll(query, interval) {
-	return Effect.gen(function* () {
-		if ((yield* Platform).isVisibleUnsafe()) yield* Effect.forkChild(refetch(query), { startImmediately: true });
-	}).pipe(Effect.delay(interval), Effect.forever);
-}
-//#endregion
-export { TypeId, changes, get, getOptimisticResultUnsafe, getUnsafe, isQueryObserver, make, makeUnsafe, observer_exports, setOptionsUnsafe, subscribeUnsafe, trackProp, trackResult, trackThenable };

package/dist/platform.d.mts

@@ -1,27 +0,0 @@
-import { Context, Effect } from "effect";
-declare namespace platform_d_exports {
-  export { Platform, PlatformEvent, whenOnline };
-}
-/** `"focus"`: the page became visible. `"online"`: the browser reconnected. */
-export type PlatformEvent = "focus" | "online";
-/**
- * The page a cache runs in: whether there is one, and its focus and network
- * state. The default reads the global `window`, `document` and `navigator`;
- * provide another to run a cache against a fake page.
- */
-export interface Platform {
-  isOnlineUnsafe(): boolean;
-  /** No page to watch: a server render. */
-  readonly isServer: boolean;
-  isVisibleUnsafe(): boolean;
-  /** Call `listener` on every focus and reconnect until unsubscribed. */
-  subscribeUnsafe(listener: (event: PlatformEvent) => void): () => void;
-}
-export declare const Platform: Context.Reference<Platform>;
-/**
- * Succeeds now if the platform is online, else on its next `"online"` event.
- * Interrupting it unsubscribes.
- */
-export declare const whenOnline: Effect.Effect<void>;
-//#endregion
-export { platform_d_exports };

package/dist/platform.mjs

@@ -1,44 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { Context, Effect } from "effect";
-//#region src/platform.ts
-var platform_exports = /* @__PURE__ */ __exportAll({
-	Platform: () => Platform,
-	whenOnline: () => whenOnline
-});
-const globalPlatform = {
-	isOnlineUnsafe: () => !("window" in globalThis) || !("navigator" in globalThis) || !("onLine" in navigator) || navigator.onLine,
-	get isServer() {
-		return !("window" in globalThis);
-	},
-	isVisibleUnsafe: () => !("document" in globalThis) || document.visibilityState !== "hidden",
-	subscribeUnsafe(listener) {
-		if (!("window" in globalThis)) return () => {};
-		const onVisibilityChange = () => {
-			if (document.visibilityState === "visible") listener("focus");
-		};
-		const onOnline = () => listener("online");
-		window.addEventListener("visibilitychange", onVisibilityChange);
-		window.addEventListener("online", onOnline);
-		return () => {
-			window.removeEventListener("visibilitychange", onVisibilityChange);
-			window.removeEventListener("online", onOnline);
-		};
-	}
-};
-const Platform = /*#__PURE__*/ Context.Reference("@raf-query/core/Platform", { defaultValue: () => globalPlatform });
-/**
-* Succeeds now if the platform is online, else on its next `"online"` event.
-* Interrupting it unsubscribes.
-*/
-const whenOnline = /*#__PURE__*/ Effect.gen(function* () {
-	const platform = yield* Platform;
-	if (platform.isOnlineUnsafe()) return;
-	yield* Effect.callback((resume) => {
-		const unsubscribe = platform.subscribeUnsafe((event) => {
-			if (event === "online") resume(Effect.void);
-		});
-		return Effect.sync(unsubscribe);
-	});
-});
-//#endregion
-export { Platform, platform_exports, whenOnline };

package/dist/query.d.mts

@@ -1,137 +0,0 @@
-import { QueryKey } from "./key.mjs";
-import { AnyQueryOptions, DataOf, ErrorOf, QueryFactory, QueryHandle, QueryMeta, ServicesOf } from "./options.mjs";
-import { Direction } from "./infinite.mjs";
-import { Thenable } from "./thenable.mjs";
-import { CancelledError as CancelledError$1, DisabledError as DisabledError$1, TypeId as TypeId$1, entry_d_exports } from "./entry.mjs";
-import { Effect, Pipeable, Stream } from "effect";
-declare namespace query_d_exports {
-  export { CancelledError, DisabledError, FetchRequest, Query, State, SubscribeOptions, TypeId, changes, fetch, fetchNextPage, fetchPreviousPage, get, getUnsafe, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isQuery, isStaleUnsafe, metaUnsafe, observerCountUnsafe, readUnsafe, refetch, reset, returnsEffectUnsafe, revalidateUnsafe, subscribeUnsafe };
-}
-export declare const TypeId: typeof TypeId$1;
-export type TypeId = typeof TypeId;
-/**
- * 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`. */
-  readonly hash: string;
-  readonly key: QueryKey;
-  /** Options from the latest factory call; `undefined` for an entry only hydrated so far. */
-  readonly options: AnyQueryOptions | undefined;
-  readonly [TypeId]: {
-    readonly _A: (_: never) => DataOf<TFactory>;
-    readonly _E: (_: never) => 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. */
-  readonly data: TData | undefined;
-  /** Error of the last failed request, or `null`. */
-  readonly error: unknown;
-  /** Failed attempts of the current request, retries included. */
-  readonly failureCount: number;
-  /** Set while a paged query loads a page at one end of the list. */
-  readonly fetchDirection: Direction | undefined;
-  readonly hasData: boolean;
-  /** A request is in flight. */
-  readonly isFetching: boolean;
-  /** Marked stale by `invalidate`; cleared by the next successful request. */
-  readonly isInvalidated: boolean;
-  /** Older than `staleTime`, invalidated, or without data. */
-  readonly isStale: boolean;
-  /**
-   * Settles with `data`. A new promise is created per data version, already
-   * fulfilled once data exists, so it can be read synchronously.
-   */
-  readonly promise: Thenable<TData>;
-  readonly status: "error" | "pending" | "success";
-  /** When `data` was fetched (ms since epoch); `0` without data. */
-  readonly updatedAt: number;
-}
-/** Per-reader preferences, registered with {@link subscribeUnsafe}. */
-export interface SubscribeOptions {
-  readonly refetchOnReconnect?: boolean;
-  readonly refetchOnWindowFocus?: boolean;
-}
-export interface FetchRequest {
-  /** Load one more page at this end of a paged query. */
-  readonly direction?: Direction;
-  /** Pages to load when a paged query has none yet. */
-  readonly pages?: number;
-  /** Interrupt an in-flight request and start over (used by `invalidate`). */
-  readonly restart?: boolean;
-}
-export declare const CancelledError: typeof CancelledError$1;
-export type CancelledError = CancelledError$1;
-export declare const DisabledError: typeof DisabledError$1;
-export type DisabledError = DisabledError$1;
-export declare const isQuery: (value: unknown) => value is Query;
-/**
- * Start a request, or join the one in flight. Fails with the request's
- * error, or a {@link CancelledError} if the entry leaves the cache first.
- * The entry's requests run with this fiber's services from now on, as after
- * a `QueryCache` verb.
- */
-export declare const fetch: {
-  (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<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<void>;
-/** Load the page after the last one; succeeds once it settles. */
-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<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<void>;
-/** Mark stale, and refetch if read; succeeds once that refetch settles. */
-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<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<TFactory extends QueryFactory>(self: Query<TFactory>): QueryMeta | undefined;
-/**
- * Whether the query's `queryFn` returns an Effect (`true`) or a promise or
- * plain value (`false`), as of its last call, on this cache or the one its
- * data was hydrated from. `undefined` until one has run. Bindings read typed
- * errors as a `Result` only for Effects.
- */
-export declare function returnsEffectUnsafe<TFactory extends QueryFactory>(self: Query<TFactory>): boolean | undefined;
-/** The entry's current state. */
-export declare function get<TFactory extends QueryFactory>(self: Query<TFactory>): Effect.Effect<State<DataOf<TFactory>>>;
-/** {@link get}, synchronously. */
-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<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<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<TFactory extends QueryFactory>(self: Query<TFactory>): void;
-/** Listen for state changes. Subscribed entries count as read. */
-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<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<TFactory extends QueryFactory>(self: Query<TFactory>): number;
-//#endregion
-export { query_d_exports };

package/dist/query.mjs

@@ -1,147 +0,0 @@
-import { __exportAll } from "./_virtual/_rolldown/runtime.mjs";
-import { CancelledError as CancelledError$1, DisabledError as DisabledError$1, TypeId as TypeId$1, changes as changes$1, entryOf, fetch as fetch$1, hasNextPageUnsafe as hasNextPageUnsafe$1, hasPreviousPageUnsafe as hasPreviousPageUnsafe$1, invalidate as invalidate$1, isQuery as isQuery$1, isStaleUnsafe as isStaleUnsafe$1, metaOf, provide, readUnsafe as readUnsafe$1, reset as reset$1, revalidate, subscribeUnsafe as subscribeUnsafe$1 } from "./entry.mjs";
-import { Effect } from "effect";
-import { dual } from "effect/Function";
-//#region src/query.ts
-/**
-* One cache entry, as a data type: a `Query` carries its key, handle and
-* options, and the functions here read it, subscribe to it and run its
-* requests. Get one from `QueryCache.getQuery(factory, input)`.
-*
-* Requests are Effects. The `*Unsafe` functions read and subscribe
-* synchronously, for renders and external stores that can't run an Effect.
-*/
-var query_exports = /* @__PURE__ */ __exportAll({
-	CancelledError: () => CancelledError,
-	DisabledError: () => DisabledError,
-	TypeId: () => TypeId,
-	changes: () => changes,
-	fetch: () => fetch,
-	fetchNextPage: () => fetchNextPage,
-	fetchPreviousPage: () => fetchPreviousPage,
-	get: () => get,
-	getUnsafe: () => getUnsafe,
-	hasNextPageUnsafe: () => hasNextPageUnsafe,
-	hasPreviousPageUnsafe: () => hasPreviousPageUnsafe,
-	invalidate: () => invalidate,
-	isQuery: () => isQuery,
-	isStaleUnsafe: () => isStaleUnsafe,
-	metaUnsafe: () => metaUnsafe,
-	observerCountUnsafe: () => observerCountUnsafe,
-	readUnsafe: () => readUnsafe,
-	refetch: () => refetch,
-	reset: () => reset,
-	returnsEffectUnsafe: () => returnsEffectUnsafe,
-	revalidateUnsafe: () => revalidateUnsafe,
-	subscribeUnsafe: () => subscribeUnsafe
-});
-const TypeId = TypeId$1;
-const CancelledError = CancelledError$1;
-const DisabledError = DisabledError$1;
-const isQuery = isQuery$1;
-function typed(effect) {
-	return effect;
-}
-function typedState(state) {
-	return state;
-}
-/**
-* Start a request, or join the one in flight. Fails with the request's
-* error, or a {@link CancelledError} if the entry leaves the cache first.
-* The entry's requests run with this fiber's services from now on, as after
-* a `QueryCache` verb.
-*/
-const fetch = dual((args) => isQuery(args[0]), (self, request) => typed(Effect.contextWith((caller) => {
-	const entry = entryOf(self);
-	provide(entry, caller);
-	return fetch$1(entry, request);
-})));
-/** Refetch now; succeeds when the request settles, whatever its outcome. */
-function refetch(self) {
-	return entryOf(self).commands.refetch;
-}
-/** Load the page after the last one; succeeds once it settles. */
-function fetchNextPage(self) {
-	return entryOf(self).commands.fetchNextPage;
-}
-/** Load the page before the first one; succeeds once it settles. */
-function fetchPreviousPage(self) {
-	return entryOf(self).commands.fetchPreviousPage;
-}
-/** Mark stale, and refetch if read; succeeds once that refetch settles. */
-function invalidate(self) {
-	return invalidate$1(entryOf(self));
-}
-/**
-* Drop data and errors, back to the state of a new entry. Readers suspend
-* and refetch; succeeds when that refetch settles.
-*/
-function reset(self) {
-	return reset$1(entryOf(self));
-}
-/**
-* The query's `meta`: the latest factory call's (the one it was hydrated
-* with, before any), else the cache default's.
-*/
-function metaUnsafe(self) {
-	return metaOf(entryOf(self));
-}
-/**
-* Whether the query's `queryFn` returns an Effect (`true`) or a promise or
-* plain value (`false`), as of its last call, on this cache or the one its
-* data was hydrated from. `undefined` until one has run. Bindings read typed
-* errors as a `Result` only for Effects.
-*/
-function returnsEffectUnsafe(self) {
-	return entryOf(self).returnsEffect;
-}
-/** The entry's current state. */
-function get(self) {
-	return Effect.sync(() => getUnsafe(self));
-}
-/** {@link get}, synchronously. */
-function getUnsafe(self) {
-	return typedState(entryOf(self).state);
-}
-/**
-* The entry's current state, then every change. Counts as a reader while
-* the stream runs, so invalidation and focus refetch it.
-*/
-function changes(self) {
-	return changes$1(entryOf(self));
-}
-/**
-* 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(self) {
-	return readUnsafe$1(entryOf(self));
-}
-/**
-* 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.
-*/
-function revalidateUnsafe(self) {
-	revalidate(entryOf(self));
-}
-/** Listen for state changes. Subscribed entries count as read. */
-function subscribeUnsafe(self, listener, options) {
-	return subscribeUnsafe$1(entryOf(self), listener, options);
-}
-/** Staleness as of now; `state.isStale` is only kept current while read. */
-function isStaleUnsafe(self) {
-	return isStaleUnsafe$1(entryOf(self));
-}
-function hasNextPageUnsafe(self) {
-	return hasNextPageUnsafe$1(entryOf(self));
-}
-function hasPreviousPageUnsafe(self) {
-	return hasPreviousPageUnsafe$1(entryOf(self));
-}
-/** Readers currently subscribed. */
-function observerCountUnsafe(self) {
-	return entryOf(self).listeners.size;
-}
-//#endregion
-export { CancelledError, DisabledError, TypeId, changes, fetch, fetchNextPage, fetchPreviousPage, get, getUnsafe, hasNextPageUnsafe, hasPreviousPageUnsafe, invalidate, isQuery, isStaleUnsafe, metaUnsafe, observerCountUnsafe, query_exports, readUnsafe, refetch, reset, returnsEffectUnsafe, revalidateUnsafe, subscribeUnsafe };